@nodaro/prompts 1.0.1

package/src/music-mood.ts

@@ -0,0 +1,137 @@
+/**
+ * Music mood catalog: energy + emotion + vibe sub-fields.
+ * Composed by buildMusicMoodHints into "[energy] [emotion] [vibe]".
+ */
+
+import { pickIds } from "@nodaro/shared"
+
+export interface MusicMoodEntry {
+  readonly id: string
+  readonly label: string
+  readonly description: string
+  readonly promptHint: string
+}
+
+export const MUSIC_ENERGIES: ReadonlyArray<MusicMoodEntry> = [
+  { id: "low",          label: "Low",          description: "Calm, slow",                 promptHint: "low-energy" },
+  { id: "mellow",       label: "Mellow",       description: "Relaxed, laid-back",         promptHint: "mellow" },
+  { id: "gentle",       label: "Gentle",       description: "Soft, tender",               promptHint: "gentle" },
+  { id: "moderate",     label: "Moderate",     description: "Balanced, steady",           promptHint: "moderate-energy" },
+  { id: "building",     label: "Building",     description: "Slowly intensifying",        promptHint: "building energy" },
+  { id: "upbeat",       label: "Upbeat",       description: "Lively, optimistic",         promptHint: "upbeat" },
+  { id: "driving",      label: "Driving",      description: "Forward-pushing momentum",   promptHint: "driving" },
+  { id: "high",         label: "High",         description: "Energetic, intense",         promptHint: "high-energy" },
+  { id: "explosive",    label: "Explosive",    description: "Bursting, wild",             promptHint: "explosive" },
+  { id: "frenetic",     label: "Frenetic",     description: "Intense, rapid",             promptHint: "frenetic" },
+  { id: "pulsing",      label: "Pulsing",      description: "Rhythmic, beat-driven",      promptHint: "pulsing" },
+  { id: "throbbing",    label: "Throbbing",    description: "Heavy, hypnotic",            promptHint: "throbbing" },
+  { id: "simmering",    label: "Simmering",    description: "Tense, restrained",          promptHint: "simmering" },
+  { id: "ferocious",    label: "Ferocious",    description: "Aggressive, relentless",     promptHint: "ferocious" },
+] as const
+
+export const MUSIC_EMOTIONS: ReadonlyArray<MusicMoodEntry> = [
+  { id: "happy",        label: "Happy",        description: "Joyful, bright",             promptHint: "happy" },
+  { id: "joyful",       label: "Joyful",       description: "Exuberant, celebratory",     promptHint: "joyful" },
+  { id: "euphoric",     label: "Euphoric",     description: "Ecstatic, transcendent",     promptHint: "euphoric" },
+  { id: "melancholic",  label: "Melancholic",  description: "Wistful, bittersweet",       promptHint: "melancholic" },
+  { id: "sad",          label: "Sad",          description: "Somber, sorrowful",          promptHint: "sad" },
+  { id: "longing",      label: "Longing",      description: "Yearning, aching",           promptHint: "longing" },
+  { id: "lonely",       label: "Lonely",       description: "Isolated, distant",          promptHint: "lonely" },
+  { id: "angry",        label: "Angry",        description: "Aggressive, hostile",        promptHint: "angry" },
+  { id: "defiant",      label: "Defiant",      description: "Rebellious, resistant",      promptHint: "defiant" },
+  { id: "triumphant",   label: "Triumphant",   description: "Heroic, victorious",         promptHint: "triumphant" },
+  { id: "victorious",   label: "Victorious",   description: "Conquering, anthemic",       promptHint: "victorious" },
+  { id: "tender",       label: "Tender",       description: "Soft, affectionate",         promptHint: "tender" },
+  { id: "romantic",     label: "Romantic",     description: "Loving, sensual",            promptHint: "romantic" },
+  { id: "haunting",     label: "Haunting",     description: "Eerie, lingering",           promptHint: "haunting" },
+  { id: "mysterious",   label: "Mysterious",   description: "Enigmatic, secretive",       promptHint: "mysterious" },
+  { id: "menacing",     label: "Menacing",     description: "Threatening, foreboding",    promptHint: "menacing" },
+  { id: "playful",      label: "Playful",      description: "Whimsical, fun",             promptHint: "playful" },
+  { id: "mischievous",  label: "Mischievous",  description: "Sly, troublemaker",          promptHint: "mischievous" },
+  { id: "anxious",      label: "Anxious",      description: "Tense, apprehensive",        promptHint: "anxious" },
+  { id: "fearful",      label: "Fearful",      description: "Afraid, panicked",           promptHint: "fearful" },
+  { id: "hopeful",      label: "Hopeful",      description: "Uplifting, aspirational",    promptHint: "hopeful" },
+  { id: "inspirational",label: "Inspirational",description: "Motivational, soaring",      promptHint: "inspirational" },
+  { id: "nostalgic",    label: "Nostalgic",    description: "Backward-looking, wistful",  promptHint: "nostalgic" },
+  { id: "bittersweet",  label: "Bittersweet",  description: "Sweet sorrow, mixed",        promptHint: "bittersweet" },
+  { id: "peaceful",     label: "Peaceful",     description: "Serene, restful",            promptHint: "peaceful" },
+  { id: "contemplative",label: "Contemplative",description: "Reflective, thoughtful",     promptHint: "contemplative" },
+  { id: "ethereal",     label: "Ethereal",     description: "Otherworldly, floating",     promptHint: "ethereal" },
+  { id: "awe",          label: "Awe",          description: "Wonder, vastness",           promptHint: "awe-inspiring" },
+] as const
+
+export const MUSIC_VIBES: ReadonlyArray<MusicMoodEntry> = [
+  { id: "cinematic",    label: "Cinematic",    description: "Score-like, evocative",      promptHint: "cinematic" },
+  { id: "intimate",     label: "Intimate",     description: "Personal, close",            promptHint: "intimate" },
+  { id: "epic",         label: "Epic",         description: "Grand, sweeping",            promptHint: "epic" },
+  { id: "anthemic",     label: "Anthemic",     description: "Crowd-singing big",          promptHint: "anthemic" },
+  { id: "lo-fi",        label: "Lo-fi",        description: "Warm, imperfect",            promptHint: "lo-fi" },
+  { id: "polished",     label: "Polished",     description: "Pristine, mainstream",       promptHint: "polished" },
+  { id: "raw",          label: "Raw",          description: "Unfiltered, gritty",         promptHint: "raw" },
+  { id: "dreamy",       label: "Dreamy",       description: "Hazy, surreal",              promptHint: "dreamy" },
+  { id: "hypnotic",     label: "Hypnotic",     description: "Looped, trance-like",        promptHint: "hypnotic" },
+  { id: "dark",         label: "Dark",         description: "Brooding, shadowy",          promptHint: "dark" },
+  { id: "gritty",       label: "Gritty",       description: "Coarse, urban",              promptHint: "gritty" },
+  { id: "uplifting",    label: "Uplifting",    description: "Bright, encouraging",        promptHint: "uplifting" },
+  { id: "tense",        label: "Tense",        description: "Suspenseful",                promptHint: "tense" },
+  { id: "spacey",       label: "Spacey",       description: "Cosmic, vast",               promptHint: "spacey" },
+  { id: "psychedelic",  label: "Psychedelic",  description: "Mind-bending, swirling",     promptHint: "psychedelic" },
+  { id: "noir",         label: "Noir",         description: "Smoky, hard-boiled",         promptHint: "noir" },
+  { id: "vintage",      label: "Vintage",      description: "Retro, period-aged",         promptHint: "vintage" },
+  { id: "futuristic",   label: "Futuristic",   description: "Sci-fi, forward-looking",    promptHint: "futuristic" },
+  { id: "suspenseful",  label: "Suspenseful",  description: "Dread, edge-of-seat",          promptHint: "suspenseful" },
+  { id: "espionage",    label: "Espionage",    description: "Spy-thriller, covert ops",      promptHint: "espionage" },
+  { id: "cold",         label: "Cold",         description: "Icy, detached, stark",          promptHint: "cold" },
+  { id: "clandestine",  label: "Clandestine",  description: "Secret, shadowy, covert",       promptHint: "clandestine" },
+] as const
+
+const ENERGY_BY_ID = new Map(MUSIC_ENERGIES.map((x) => [x.id, x]))
+const EMOTION_BY_ID = new Map(MUSIC_EMOTIONS.map((x) => [x.id, x]))
+const VIBE_BY_ID = new Map(MUSIC_VIBES.map((x) => [x.id, x]))
+
+export function getMusicEnergy(id: string | undefined): MusicMoodEntry | undefined {
+  return id ? ENERGY_BY_ID.get(id) : undefined
+}
+export function getMusicEmotion(id: string | undefined): MusicMoodEntry | undefined {
+  return id ? EMOTION_BY_ID.get(id) : undefined
+}
+export function getMusicVibe(id: string | undefined): MusicMoodEntry | undefined {
+  return id ? VIBE_BY_ID.get(id) : undefined
+}
+
+export function buildMusicMoodHints(data: {
+  readonly preText?: string
+  readonly postText?: string
+  readonly energy?: string
+  readonly emotion?: string | ReadonlyArray<string>
+  readonly vibe?: string | ReadonlyArray<string>
+}): string {
+  const fragments: string[] = []
+  const pre = typeof data.preText === "string" ? data.preText.trim() : ""
+  if (pre) fragments.push(pre)
+
+  const parts: string[] = []
+  const e = getMusicEnergy(data.energy)
+  if (e) parts.push(e.promptHint)
+
+  const emotionHints = pickIds(data.emotion)
+    .map((id) => getMusicEmotion(id)?.promptHint)
+    .filter((h): h is string => !!h)
+  if (emotionHints.length > 0) parts.push(emotionHints.join(", "))
+
+  const vibeHints = pickIds(data.vibe)
+    .map((id) => getMusicVibe(id)?.promptHint)
+    .filter((h): h is string => !!h)
+  if (vibeHints.length > 0) parts.push(vibeHints.join(", "))
+
+  if (parts.length > 0) fragments.push(parts.join(" "))
+
+  const post = typeof data.postText === "string" ? data.postText.trim() : ""
+  if (post) fragments.push(post)
+
+  return fragments.join(", ")
+}
+
+export const MUSIC_MOOD_DEFAULT_DATA: {
+  preText?: string; postText?: string; energy?: string; emotion?: string | ReadonlyArray<string>; vibe?: string | ReadonlyArray<string>
+} = {}

package/src/object-asset-presets.ts

@@ -0,0 +1,81 @@
+// Object Studio asset presets — SINGLE SOURCE OF TRUTH for the Angles /
+// Materials / Variations preset chips AND their generation prompt fragments.
+//
+// Both the frontend tab wrappers (`object-studio/{angles,materials,variations}-tab.tsx`)
+// and the backend route (`generate-object-asset.ts` — VARIANTS validation +
+// buildVariantPrompt) import from here, so the preset list can never drift
+// between client and server.
+//
+// Why this file exists: the frontend shipped 9 / 13 / 11 presets while the
+// backend enum only accepted 5 / 6 / 5, so ~17 chips 400'd with a silent
+// failure (the route rejects any variant not in VARIANTS, and the studio sent
+// them as assetType:"angles|materials|variations", NOT "custom"). Deriving both
+// sides from one constant is the drift-proof fix.
+//
+// To add a preset: add ONE entry to the matching prompt map below. The key list
+// and the backend validation update automatically.
+
+/** Angle preset → prompt fragment (slotted into "<name>, <fragment>. <base>"). */
+export const OBJECT_ANGLE_PROMPTS: Record<string, string> = {
+  front: "front view, facing camera directly",
+  side: "side profile view",
+  top: "top-down view, bird's eye perspective",
+  back: "back view, rear perspective",
+  "three-quarter": "three-quarter angle view, dynamic perspective",
+  detail: "extreme close-up detail shot, macro view of the surface and craftsmanship",
+  "in-context": "shown in its natural environment and use context, real-world setting",
+  exploded: "exploded technical view, components separated and floating apart",
+  perspective: "dramatic low-angle perspective view, strong sense of depth",
+}
+
+/** Material preset → prompt fragment. */
+export const OBJECT_MATERIAL_PROMPTS: Record<string, string> = {
+  wood: "made of polished wood, wood grain texture visible",
+  metal: "made of brushed metal, metallic surface with subtle reflections",
+  glass: "made of transparent glass, see-through with subtle reflections",
+  plastic: "made of smooth plastic, matte finish",
+  fabric: "covered in soft fabric texture, textile material",
+  stone: "carved from stone, rough granite or marble texture",
+  ceramic: "made of glazed ceramic, smooth glossy fired-clay surface",
+  leather: "wrapped in tanned leather, natural grain and visible stitching",
+  paper: "made of folded paper and cardboard, matte fibrous texture",
+  gold: "made of polished gold, warm reflective precious-metal sheen",
+  silver: "made of polished silver, cool bright reflective metal",
+  copper: "made of copper, warm reddish metal with a subtle patina",
+  marble: "carved from marble, smooth polished stone with natural veining",
+}
+
+/** Variation preset → prompt fragment. */
+export const OBJECT_VARIATION_PROMPTS: Record<string, string> = {
+  clean: "brand new pristine condition, perfect and clean",
+  weathered: "slightly weathered and aged, with wear marks",
+  damaged: "battle-damaged with scratches and dents",
+  ornate: "ornately decorated with intricate details and patterns",
+  minimal: "minimalist design, clean simple lines",
+  broken: "broken and cracked, shattered with missing pieces",
+  antique: "antique vintage version, aged patina and period detailing",
+  futuristic: "sleek futuristic sci-fi redesign, advanced materials with a subtle glow",
+  holographic: "iridescent holographic finish, rainbow refractive sheen",
+  dirty: "dirty and grimy, covered in dust, mud and stains",
+  polished: "immaculately polished, mirror-bright showroom finish",
+}
+
+export const OBJECT_ANGLE_PRESETS: readonly string[] = Object.keys(OBJECT_ANGLE_PROMPTS)
+export const OBJECT_MATERIAL_PRESETS: readonly string[] = Object.keys(OBJECT_MATERIAL_PROMPTS)
+export const OBJECT_VARIATION_PRESETS: readonly string[] = Object.keys(OBJECT_VARIATION_PROMPTS)
+
+export type ObjectPresetAssetType = "angles" | "materials" | "variations"
+
+/** Preset key lists per asset type — backend VARIANTS validation reads this. */
+export const OBJECT_ASSET_PRESETS: Record<ObjectPresetAssetType, readonly string[]> = {
+  angles: OBJECT_ANGLE_PRESETS,
+  materials: OBJECT_MATERIAL_PRESETS,
+  variations: OBJECT_VARIATION_PRESETS,
+}
+
+/** Prompt-fragment maps per asset type — backend buildVariantPrompt reads this. */
+export const OBJECT_ASSET_PROMPTS: Record<ObjectPresetAssetType, Record<string, string>> = {
+  angles: OBJECT_ANGLE_PROMPTS,
+  materials: OBJECT_MATERIAL_PROMPTS,
+  variations: OBJECT_VARIATION_PROMPTS,
+}

package/src/parameter-prompt-hint.ts

@@ -0,0 +1,281 @@
+import type { HintNodeLike, HintEdgeLike, HintGraphContext } from "@nodaro/shared"
+export type { HintNodeLike, HintEdgeLike, HintGraphContext }
+/**
+ * Single source of truth for parameter-node prompt-hint text.
+ *
+ * Every parameter node (framing, lens, camera-format, lighting, color-look,
+ * atmosphere, style, setting, person, mood, pose, styling, temporal, tone,
+ * text-prompt, camera-motion) dispatches through `getParameterPromptHint` to
+ * produce the descriptive clause it contributes to a consumer's prompt.
+ *
+ * The frontend DAG executor and backend workflow orchestrator both call this,
+ * so the text injected via the `cinematography` handle is identical to the
+ * text injected when the node is wired directly into a Text Prompt / LLM Chat
+ * / Combine Text input.
+ *
+ * Camera-motion is graph-aware: when `ctx` is provided the function walks the
+ * node's `startState`/`endState` incoming edges and composes a fully formed
+ * sentence via `composeCameraMotionHintFromConnections`. Without `ctx` only
+ * the bare motion description is returned.
+ */
+
+import { buildFramingHints } from "./framing.js"
+import { buildLightingHints } from "./lighting.js"
+import { getLensPromptHint } from "./lens.js"
+import { getCameraFormatPromptHint } from "./camera-format.js"
+import { getColorLookPromptHint } from "./color-look.js"
+import { buildAtmosphereHints } from "./atmosphere.js"
+import { buildActionFxHints } from "./action-fx.js"
+import { getStylePromptHint } from "./style.js"
+import { getSettingPromptHint } from "./setting.js"
+import { getLoopSubjectPromptHint } from "./loop-subject.js"
+import { buildPersonHints } from "./person.js"
+import { buildMoodHints } from "./mood.js"
+import { buildPoseHints } from "./pose.js"
+import { buildStylingHints } from "./styling.js"
+import { buildTemporalHints } from "./temporal.js"
+import { composeCameraMotionHintFromConnections } from "./camera-motions.js"
+import { composeTransitionHintFromConnections, 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 { buildMaterialHints } from "./materials.js"
+import { getAnimal } from "@nodaro/shared"
+import { getVehicle } from "@nodaro/shared"
+import { getWeapon } from "@nodaro/shared"
+import { getFurniture } from "@nodaro/shared"
+import { getPhotoGenrePromptHint } from "./photo-genre.js"
+import { getBackdropPromptHint } from "./backdrop.js"
+import { buildHeldPropHints } from "./held-prop.js"
+import { buildPhotographerHints } from "./photographer.js"
+import { buildAestheticHints } from "./aesthetic.js"
+import { getEraPromptHint } from "./era.js"
+import { buildExposureHints } from "./exposure-settings.js"
+import { getRenderQualityPromptHint } from "./render-quality.js"
+import { getCompositionEffectPromptHint } from "./composition-effects.js"
+import { buildPostProcessHints } from "./post-process-effects.js"
+import { buildMusicGenreHints } from "./music-genre.js"
+import { buildMusicMoodHints } from "./music-mood.js"
+import { buildInstrumentationHints } from "./instrumentation.js"
+import { buildVoiceCharacterHints } from "./voice-character.js"
+import { buildVoiceDeliveryHints } from "./voice-delivery.js"
+
+
+function asStr(v: unknown): string {
+  return typeof v === "string" ? v : ""
+}
+
+/** Extract the display name from a character / face / object / location ref node. */
+function extractCharacterRefName(node: HintNodeLike): string | undefined {
+  const d = (node.data ?? {}) as Record<string, unknown>
+  const candidates = [d.characterName, d.faceName, d.objectName, d.locationName]
+  for (const v of candidates) {
+    if (typeof v === "string" && v.trim().length > 0) return v.trim()
+  }
+  return undefined
+}
+
+/** Compose `[preText, mainHint, postText]` into a comma-joined string,
+ *  honoring the user's free-text fragments around the structured hint.
+ *  Helpers like `getStylePromptHint` that already include preText/postText
+ *  composition (build*Hints in mood/person/etc.) bypass this — they
+ *  return the fully-composed string directly. */
+function withCustomText(data: Record<string, unknown>, mainHint: string): string {
+  const fragments: string[] = []
+  const pre = typeof data.preText === "string" ? data.preText.trim() : ""
+  if (pre) fragments.push(pre)
+  if (mainHint) fragments.push(mainHint)
+  const post = typeof data.postText === "string" ? data.postText.trim() : ""
+  if (post) fragments.push(post)
+  return fragments.join(", ")
+}
+
+/**
+ * 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
+ * bare motion description is returned.
+ */
+export function getParameterPromptHint(
+  node: HintNodeLike | undefined,
+  ctx?: HintGraphContext,
+): string {
+  if (!node?.type) return ""
+  const data = (node.data ?? {}) as Record<string, unknown>
+
+  if (node.type === "camera-motion") {
+    const motionId = asStr(data.cameraMotion) || undefined
+    if (!ctx) return withCustomText(data, composeCameraMotionHintFromConnections(motionId, [], []))
+    const startHints: string[] = []
+    const endHints: string[] = []
+    for (const edge of ctx.edges) {
+      if (edge.target !== node.id) continue
+      const src = ctx.nodes.find((n) => n.id === edge.source)
+      if (!src) continue
+      // Pass no ctx for nested resolution: startState/endState inputs are
+      // themselves parameter nodes (framing/tone/etc.) that don't need graph
+      // context, and avoiding recursion keeps the walk cycle-safe.
+      const hint = getParameterPromptHint(src)
+      if (!hint) continue
+      if (edge.targetHandle === "startState") startHints.push(hint)
+      else if (edge.targetHandle === "endState") endHints.push(hint)
+    }
+    return withCustomText(data, composeCameraMotionHintFromConnections(motionId, startHints, endHints))
+  }
+
+  if (node.type === "transition") {
+    const raw = data.transition
+    const transitionId: string | string[] | undefined =
+      Array.isArray(raw)
+        ? raw.filter((s): s is string => typeof s === "string" && s.length > 0)
+        : (asStr(raw) || undefined)
+    const timing: TransitionTiming = {
+      position:  asStr(data.position)  as TransitionPosition  | undefined,
+      duration:  asStr(data.duration)  as TransitionDuration  | undefined,
+      intensity: asStr(data.intensity) as TransitionIntensity | undefined,
+    }
+    if (!ctx) {
+      return withCustomText(data, composeTransitionHintFromConnections(transitionId, [], [], timing))
+    }
+    const startHints: string[] = []
+    const endHints: string[] = []
+    for (const edge of ctx.edges) {
+      if (edge.target !== node.id) continue
+      const src = ctx.nodes.find((n) => n.id === edge.source)
+      if (!src) continue
+      const hint = getParameterPromptHint(src) // no ctx — cycle-safe
+      if (!hint) continue
+      if      (edge.targetHandle === "startState") startHints.push(hint)
+      else if (edge.targetHandle === "endState")   endHints.push(hint)
+    }
+    return withCustomText(data, composeTransitionHintFromConnections(transitionId, startHints, endHints, timing))
+  }
+
+  if (node.type === "character-fx") {
+    const raw = data.characterFx
+    const effectId: string | string[] | undefined =
+      Array.isArray(raw)
+        ? raw.filter((s): s is string => typeof s === "string" && s.length > 0)
+        : (asStr(raw) || undefined)
+    const timing: CharacterFxTiming = {
+      position:  asStr(data.position)  as CharacterFxPosition  | undefined,
+      duration:  asStr(data.duration)  as CharacterFxDuration  | undefined,
+      intensity: asStr(data.intensity) as CharacterFxIntensity | undefined,
+    }
+    if (!ctx) {
+      return withCustomText(data, composeCharacterFxHintFromConnections(effectId, [], timing))
+    }
+    const targetNames: string[] = []
+    for (const edge of ctx.edges) {
+      if (edge.target !== node.id) continue
+      if (edge.targetHandle !== "target") continue
+      const src = ctx.nodes.find((n) => n.id === edge.source)
+      if (!src) continue
+      const name = extractCharacterRefName(src)
+      if (name) targetNames.push(name)
+    }
+    return withCustomText(data, composeCharacterFxHintFromConnections(effectId, targetNames, timing))
+  }
+
+  switch (node.type) {
+    case "framing":
+      return withCustomText(data, buildFramingHints(data).join(", "))
+    case "lighting":
+      return withCustomText(data, buildLightingHints(data).join(", "))
+    case "lens":
+      return withCustomText(data, getLensPromptHint(asStr(data.lens)))
+    case "camera-format":
+      return withCustomText(data, getCameraFormatPromptHint(asStr(data.cameraFormat)))
+    case "color-look":
+      return withCustomText(data, getColorLookPromptHint(asStr(data.colorLook)))
+
+    // build*Hints in music-* / voice-* / mood / person / etc. compose
+    // preText/postText internally — bypass the wrapper to avoid double-
+    // composition.
+    case "music-genre":
+      return buildMusicGenreHints((data ?? {}) as Parameters<typeof buildMusicGenreHints>[0])
+    case "music-mood":
+      return buildMusicMoodHints((data ?? {}) as Parameters<typeof buildMusicMoodHints>[0])
+    case "instrumentation":
+      return buildInstrumentationHints((data ?? {}) as Parameters<typeof buildInstrumentationHints>[0])
+    case "voice-character":
+      return buildVoiceCharacterHints((data ?? {}) as Parameters<typeof buildVoiceCharacterHints>[0])
+    case "voice-delivery":
+      return buildVoiceDeliveryHints((data ?? {}) as Parameters<typeof buildVoiceDeliveryHints>[0])
+    case "person":
+      return buildPersonHints(data).join(", ")
+    case "mood":
+      return buildMoodHints(data).join(", ")
+    case "pose":
+      return buildPoseHints(data).join(", ")
+    case "styling":
+      return buildStylingHints(data).join(", ")
+
+    case "atmosphere":
+      return withCustomText(data, buildAtmosphereHints(data.atmosphere).join(", "))
+    case "action-fx":
+      return withCustomText(data, buildActionFxHints(data.actionFx).join(", "))
+    case "style":
+      return withCustomText(data, getStylePromptHint(asStr(data.style)))
+    case "setting":
+      return withCustomText(data, getSettingPromptHint(asStr(data.setting)))
+    case "loop-subject":
+      return withCustomText(data, getLoopSubjectPromptHint(asStr(data.loopSubject)))
+    case "material":
+      return withCustomText(data, buildMaterialHints(data.material))
+    case "animal": {
+      const animal = getAnimal(asStr(data.animal))
+      return withCustomText(
+        data,
+        animal ? `featuring a ${animal.label.toLowerCase()}, ${animal.description}` : "",
+      )
+    }
+    case "vehicle": {
+      const vehicle = getVehicle(asStr(data.vehicle))
+      return withCustomText(
+        data,
+        vehicle ? `featuring a ${vehicle.label.toLowerCase()}, ${vehicle.description}` : "",
+      )
+    }
+    case "weapon": {
+      const weapon = getWeapon(asStr(data.weapon))
+      return withCustomText(
+        data,
+        weapon ? `with a ${weapon.label.toLowerCase()}, ${weapon.description}` : "",
+      )
+    }
+    case "furniture": {
+      const furniture = getFurniture(asStr(data.furniture))
+      return withCustomText(
+        data,
+        furniture ? `including a ${furniture.label.toLowerCase()}, ${furniture.description}` : "",
+      )
+    }
+    case "photo-genre":
+      return withCustomText(data, getPhotoGenrePromptHint(asStr(data.photoGenre)))
+    case "backdrop":
+      return withCustomText(data, getBackdropPromptHint(asStr(data.backdrop)))
+    case "held-prop":
+      return withCustomText(data, buildHeldPropHints(data.heldProp).join(", "))
+    case "photographer":
+      return withCustomText(data, buildPhotographerHints(data.photographer))
+    case "aesthetic":
+      return withCustomText(data, buildAestheticHints(data.aesthetic))
+    case "era":
+      return withCustomText(data, getEraPromptHint(asStr(data.era)))
+    case "temporal":
+      return withCustomText(data, buildTemporalHints(data).join(", "))
+    case "exposure-settings":
+      return withCustomText(data, buildExposureHints(data).join(", "))
+    case "render-quality":
+      return withCustomText(data, getRenderQualityPromptHint(asStr(data.renderQuality)))
+    case "composition-effects":
+      return withCustomText(data, getCompositionEffectPromptHint(asStr(data.compositionEffect)))
+    case "post-process-effects":
+      return withCustomText(data, buildPostProcessHints(data.postProcess).join(", "))
+
+    case "tone":
+      return asStr(data.tone).trim()
+    case "text-prompt":
+      return asStr(data.text).trim()
+    default:
+      return ""
+  }
+}