@nodaro/prompts 1.5.0 → 1.7.0

package/src/picker-analyzer-registry.ts

@@ -10,6 +10,36 @@ import { STYLINGS, STYLING_DIMENSION_ORDER, STYLING_DIMENSION_LABELS, STYLING_FI
 import { FRAMINGS, FRAMING_CATEGORY_ORDER, FRAMING_CATEGORY_LABELS, FRAMING_FIELD_BY_CATEGORY, getFramingCategoryLimit } from "./framing.js"
 import { LENSES } from "./lens.js"
 import { CAMERA_FORMATS } from "./camera-format.js"
+import { ANIMALS, VEHICLES, WEAPONS, FURNITURE } from "@nodaro/shared"
+import { SETTINGS } from "./setting.js"
+import { ATMOSPHERES } from "./atmosphere.js"
+import { STYLES } from "./style.js"
+import { MOODS } from "./mood.js"
+import { COLOR_LOOKS } from "./color-look.js"
+import { PHOTOGRAPHERS } from "./photographer.js"
+import { AESTHETICS } from "./aesthetic.js"
+import { ERAS } from "./era.js"
+import { PHOTO_GENRES } from "./photo-genre.js"
+import { BACKDROPS } from "./backdrop.js"
+import { RENDER_QUALITIES } from "./render-quality.js"
+import { COMPOSITION_EFFECTS } from "./composition-effects.js"
+import { POST_PROCESS_EFFECTS } from "./post-process-effects.js"
+import { ACTION_FX } from "./action-fx.js"
+import { LOOP_SUBJECTS } from "./loop-subject.js"
+import { TRANSITIONS } from "./transitions.js"
+import { CHARACTER_FX } from "./character-fx.js"
+import { POSES } from "./pose.js"
+import { MATERIALS } from "./materials.js"
+import { HELD_PROPS } from "./held-prop.js"
+import { CAMERA_MOTIONS } from "./camera-motions.js"
+import { LIGHTINGS, LIGHTING_CATEGORY_ORDER, LIGHTING_CATEGORY_LABELS, LIGHTING_FIELD_BY_CATEGORY } from "./lighting.js"
+import { TEMPORALS } from "./temporal.js"
+import { EXPOSURE_SETTINGS } from "./exposure-settings.js"
+import { MUSIC_GENRES, MUSIC_ERAS } from "./music-genre.js"
+import { MUSIC_ENERGIES, MUSIC_EMOTIONS, MUSIC_VIBES } from "./music-mood.js"
+import { INSTRUMENTS, PRODUCTION_STYLES, VOCAL_PRESENCE, SINGING_STYLES } from "./instrumentation.js"
+import { VOICE_AGES, VOICE_GENDERS, VOICE_LANGUAGES, VOICE_ACCENTS, VOICE_TIMBRES } from "./voice-character.js"
+import { VOICE_PACES, VOICE_EMOTIONS, VOICE_ARCHETYPES } from "./voice-delivery.js"
 
 // ─── Descriptor model ────────────────────────────────────────────────────────
 
@@ -57,6 +87,16 @@ export type PickerAnalyzerDescriptor =
 
 const PERSON_EXCLUDED = new Set<string>(["age-custom"])
 
+/** Tag catalog entries with an explicit dimension — for discriminated pickers
+ *  whose fields live in SEPARATE catalogs (music/voice) rather than one
+ *  discriminated catalog. */
+function tagDim<T extends { id: string; label: string; description: string }>(
+  arr: ReadonlyArray<T>,
+  dimension: string,
+): ReadonlyArray<AnalyzerEntry> {
+  return arr.map((e) => ({ id: e.id, label: e.label, description: e.description, dimension }))
+}
+
 const personCleanup: ApplyCleanup = (patch, mode) => {
   if (mode === "override") {
     patch.customAge = undefined
@@ -113,10 +153,160 @@ export const PICKER_ANALYZER_REGISTRY = {
     label: "Camera / Film Stock",
     entries: CAMERA_FORMATS as ReadonlyArray<AnalyzerEntry>,
   },
+
+  // ─── Text-to-picker expansion (Cine AI Fill): every remaining catalog ─────
+  // Flat single-value pickers — field names match the picker wiring's
+  // valueField (and the node-data shape the published-app input card writes).
+  setting: { kind: "flat", toolName: "emit_setting", field: "setting", label: "Setting", entries: SETTINGS as ReadonlyArray<AnalyzerEntry> },
+  atmosphere: { kind: "flat", toolName: "emit_atmosphere", field: "atmosphere", label: "Atmosphere", entries: ATMOSPHERES as ReadonlyArray<AnalyzerEntry> },
+  style: { kind: "flat", toolName: "emit_style", field: "style", label: "Style", entries: STYLES as ReadonlyArray<AnalyzerEntry> },
+  mood: { kind: "flat", toolName: "emit_mood", field: "mood", label: "Mood", entries: MOODS as ReadonlyArray<AnalyzerEntry> },
+  "color-look": { kind: "flat", toolName: "emit_color_look", field: "colorLook", label: "Color / Look", entries: COLOR_LOOKS as ReadonlyArray<AnalyzerEntry> },
+  photographer: { kind: "flat", toolName: "emit_photographer", field: "photographer", label: "Photographer / Artist", entries: PHOTOGRAPHERS as ReadonlyArray<AnalyzerEntry> },
+  aesthetic: { kind: "flat", toolName: "emit_aesthetic", field: "aesthetic", label: "Aesthetic / Microtrend", entries: AESTHETICS as ReadonlyArray<AnalyzerEntry> },
+  era: { kind: "flat", toolName: "emit_era", field: "era", label: "Era / Period", entries: ERAS as ReadonlyArray<AnalyzerEntry> },
+  "photo-genre": { kind: "flat", toolName: "emit_photo_genre", field: "photoGenre", label: "Photo Genre", entries: PHOTO_GENRES as ReadonlyArray<AnalyzerEntry> },
+  backdrop: { kind: "flat", toolName: "emit_backdrop", field: "backdrop", label: "Backdrop", entries: BACKDROPS as ReadonlyArray<AnalyzerEntry> },
+  "render-quality": { kind: "flat", toolName: "emit_render_quality", field: "renderQuality", label: "Render Quality", entries: RENDER_QUALITIES as ReadonlyArray<AnalyzerEntry> },
+  "composition-effects": { kind: "flat", toolName: "emit_composition_effects", field: "compositionEffect", label: "Composition Effect", entries: COMPOSITION_EFFECTS as ReadonlyArray<AnalyzerEntry> },
+  "post-process-effects": { kind: "flat", toolName: "emit_post_process_effects", field: "postProcess", label: "Post-Process Effect", entries: POST_PROCESS_EFFECTS as ReadonlyArray<AnalyzerEntry> },
+  "action-fx": { kind: "flat", toolName: "emit_action_fx", field: "actionFx", label: "Action FX", entries: ACTION_FX as ReadonlyArray<AnalyzerEntry> },
+  "loop-subject": { kind: "flat", toolName: "emit_loop_subject", field: "loopSubject", label: "Loop Subject", entries: LOOP_SUBJECTS as ReadonlyArray<AnalyzerEntry> },
+  transition: { kind: "flat", toolName: "emit_transition", field: "transition", label: "Transition", entries: TRANSITIONS as ReadonlyArray<AnalyzerEntry> },
+  "character-fx": { kind: "flat", toolName: "emit_character_fx", field: "characterFx", label: "Character FX", entries: CHARACTER_FX as ReadonlyArray<AnalyzerEntry> },
+  pose: { kind: "flat", toolName: "emit_pose", field: "pose", label: "Pose", entries: POSES as ReadonlyArray<AnalyzerEntry> },
+  material: { kind: "flat", toolName: "emit_material", field: "material", label: "Material", entries: MATERIALS as ReadonlyArray<AnalyzerEntry> },
+  "held-prop": { kind: "flat", toolName: "emit_held_prop", field: "heldProp", label: "Held Prop", entries: HELD_PROPS as ReadonlyArray<AnalyzerEntry> },
+  "camera-motion": { kind: "flat", toolName: "emit_camera_motion", field: "cameraMotion", label: "Camera Motion", entries: CAMERA_MOTIONS as ReadonlyArray<AnalyzerEntry> },
+  animal: { kind: "flat", toolName: "emit_animal", field: "animal", label: "Animal", entries: ANIMALS as ReadonlyArray<AnalyzerEntry> },
+  vehicle: { kind: "flat", toolName: "emit_vehicle", field: "vehicle", label: "Vehicle", entries: VEHICLES as ReadonlyArray<AnalyzerEntry> },
+  weapon: { kind: "flat", toolName: "emit_weapon", field: "weapon", label: "Weapon", entries: WEAPONS as ReadonlyArray<AnalyzerEntry> },
+  furniture: { kind: "flat", toolName: "emit_furniture", field: "furniture", label: "Furniture", entries: FURNITURE as ReadonlyArray<AnalyzerEntry> },
+
+  // Discriminated multi-dim pickers. lighting/temporal/exposure discriminate
+  // on the single catalog's `category`; the sound/voice pickers span several
+  // per-field catalogs, so their entries are synthesized with an explicit
+  // `dimension` tag (tagDim below) — same wire shape either way.
+  lighting: {
+    kind: "discriminated",
+    toolName: "emit_lighting",
+    discriminator: "category",
+    order: LIGHTING_CATEGORY_ORDER as ReadonlyArray<string>,
+    fieldByKey: LIGHTING_FIELD_BY_CATEGORY as Readonly<Record<string, string>>,
+    labels: LIGHTING_CATEGORY_LABELS as Readonly<Record<string, string>>,
+    entries: LIGHTINGS as ReadonlyArray<AnalyzerEntry>,
+    limitFn: () => 1,
+  },
+  temporal: {
+    kind: "discriminated",
+    toolName: "emit_temporal",
+    discriminator: "category",
+    order: ["speed", "freeze", "direction", "shutter"],
+    fieldByKey: { speed: "temporalSpeed", freeze: "temporalFreeze", direction: "temporalDirection", shutter: "temporalShutter" },
+    labels: { speed: "Playback Speed", freeze: "Freeze", direction: "Direction", shutter: "Shutter" },
+    entries: TEMPORALS as ReadonlyArray<AnalyzerEntry>,
+    limitFn: () => 1,
+  },
+  "exposure-settings": {
+    kind: "discriminated",
+    toolName: "emit_exposure_settings",
+    discriminator: "category",
+    order: ["aperture", "shutter-speed", "iso"],
+    fieldByKey: { aperture: "aperture", "shutter-speed": "shutterSpeed", iso: "isoValue" },
+    labels: { aperture: "Aperture", "shutter-speed": "Shutter Speed", iso: "ISO" },
+    entries: EXPOSURE_SETTINGS as ReadonlyArray<AnalyzerEntry>,
+    limitFn: () => 1,
+  },
+  "music-genre": {
+    kind: "discriminated",
+    toolName: "emit_music_genre",
+    discriminator: "dimension",
+    order: ["genre", "subgenre", "era"],
+    fieldByKey: { genre: "genre", subgenre: "subgenre", era: "era" },
+    labels: { genre: "Genre", subgenre: "Subgenre", era: "Era" },
+    entries: [
+      ...tagDim(MUSIC_GENRES, "genre"),
+      // Subgenres carry promptHint but no description — the hint doubles as
+      // the legend text (it describes the sound well enough for matching).
+      ...MUSIC_GENRES.flatMap((g) =>
+        g.subgenres.map((s) => ({ id: s.id, label: s.label, description: s.promptHint, dimension: "subgenre" })),
+      ),
+      ...tagDim(MUSIC_ERAS, "era"),
+    ],
+    limitFn: (k) => (k === "genre" ? 2 : 1),
+  },
+  "music-mood": {
+    kind: "discriminated",
+    toolName: "emit_music_mood",
+    discriminator: "dimension",
+    order: ["energy", "emotion", "vibe"],
+    fieldByKey: { energy: "energy", emotion: "emotion", vibe: "vibe" },
+    labels: { energy: "Energy", emotion: "Emotion", vibe: "Vibe" },
+    entries: [...tagDim(MUSIC_ENERGIES, "energy"), ...tagDim(MUSIC_EMOTIONS, "emotion"), ...tagDim(MUSIC_VIBES, "vibe")],
+    limitFn: (k) => (k === "energy" ? 1 : 2),
+  },
+  instrumentation: {
+    kind: "discriminated",
+    toolName: "emit_instrumentation",
+    discriminator: "dimension",
+    order: ["instruments", "production", "vocalPresence", "singingStyle"],
+    fieldByKey: { instruments: "instruments", production: "production", vocalPresence: "vocalPresence", singingStyle: "singingStyle" },
+    labels: { instruments: "Instruments", production: "Production Style", vocalPresence: "Vocal Presence", singingStyle: "Singing Style" },
+    entries: [
+      ...tagDim(INSTRUMENTS, "instruments"),
+      ...tagDim(PRODUCTION_STYLES, "production"),
+      ...tagDim(VOCAL_PRESENCE, "vocalPresence"),
+      ...tagDim(SINGING_STYLES, "singingStyle"),
+    ],
+    limitFn: (k) => (k === "instruments" ? 3 : k === "production" ? 1 : 2),
+  },
+  "voice-character": {
+    kind: "discriminated",
+    toolName: "emit_voice_character",
+    discriminator: "dimension",
+    order: ["age", "gender", "language", "accent", "timbre"],
+    fieldByKey: { age: "age", gender: "gender", language: "language", accent: "accent", timbre: "timbre" },
+    labels: { age: "Age", gender: "Gender", language: "Language", accent: "Accent", timbre: "Timbre" },
+    entries: [
+      ...tagDim(VOICE_AGES, "age"),
+      ...tagDim(VOICE_GENDERS, "gender"),
+      ...tagDim(VOICE_LANGUAGES, "language"),
+      ...tagDim(VOICE_ACCENTS, "accent"),
+      ...tagDim(VOICE_TIMBRES, "timbre"),
+    ],
+    limitFn: (k) => (k === "language" ? 2 : 1),
+  },
+  "voice-delivery": {
+    kind: "discriminated",
+    toolName: "emit_voice_delivery",
+    discriminator: "dimension",
+    order: ["pace", "emotion", "archetype"],
+    fieldByKey: { pace: "pace", emotion: "emotion", archetype: "archetype" },
+    labels: { pace: "Pace", emotion: "Emotion", archetype: "Archetype" },
+    entries: [...tagDim(VOICE_PACES, "pace"), ...tagDim(VOICE_EMOTIONS, "emotion"), ...tagDim(VOICE_ARCHETYPES, "archetype")],
+    limitFn: () => 1,
+  },
 } satisfies Record<string, PickerAnalyzerDescriptor>
 
 export type PickerType = keyof typeof PICKER_ANALYZER_REGISTRY
 export const PICKER_TYPES = Object.keys(PICKER_ANALYZER_REGISTRY) as PickerType[]
+
+/**
+ * Family grouping for BATCHED analysis. A single call across all 38 catalogs
+ * carries a ~211k-char legend (~53k tokens — measured 2026-08-09, the
+ * measure-first probe from the text-to-picker spec), which is slow, costly,
+ * and dilutes per-section accuracy. The text-to-picker route fans out one
+ * structured call per family (6-15k tokens each) and merges. Mirrors the
+ * build-brief's §5 UI grouping so Cine can reuse the same partition.
+ */
+export const PICKER_ANALYZER_FAMILIES: Readonly<Record<string, ReadonlyArray<PickerType>>> = {
+  scene: ["setting", "atmosphere", "backdrop", "era", "temporal"],
+  look: ["style", "color-look", "mood", "aesthetic", "photographer", "photo-genre", "render-quality", "composition-effects", "post-process-effects"],
+  camera: ["framing", "camera-motion", "lens", "camera-format", "lighting", "exposure-settings"],
+  character: ["person", "styling", "pose", "character-fx"],
+  elements: ["animal", "vehicle", "weapon", "furniture", "held-prop", "material", "action-fx", "loop-subject", "transition"],
+  audio: ["music-genre", "music-mood", "instrumentation", "voice-character", "voice-delivery"],
+}
 export const ANALYZABLE_PICKER_TYPES: ReadonlySet<string> = new Set(PICKER_TYPES)
 export function isAnalyzablePicker(t: string): t is PickerType {
   return ANALYZABLE_PICKER_TYPES.has(t)

package/src/picker-wiring.ts

@@ -0,0 +1,336 @@
+/**
+ * Parameter-picker WIRING — the single source of truth for how each picker
+ * node type binds to its catalog: value field(s), defaults, entries, grouping,
+ * and per-field option lists for multi-dim pickers.
+ *
+ * Pure data, no React. Extracted from the app's parameter-picker-registry so
+ * THREE consumers share one definition and cannot drift:
+ *   1. The app's community fallback registry (chip pickers, no rich previews).
+ *   2. `@nodaroai/picker-ui`'s rich registry (attaches preview/Picker renderers).
+ *   3. Nodaro Cine's builder panels.
+ *
+ * Renderers (preview components, multi-dim Picker components) deliberately do
+ * NOT live here — presentation is the private package's concern; this file is
+ * the public vocabulary.
+ */
+import {
+  ANIMALS,
+  ANIMAL_SUBCATEGORY_LABELS,
+  ANIMAL_SUBCATEGORY_ORDER,
+  VEHICLES,
+  VEHICLE_SUBCATEGORY_LABELS,
+  VEHICLE_SUBCATEGORY_ORDER,
+  WEAPONS,
+  WEAPON_SUBCATEGORY_LABELS,
+  WEAPON_SUBCATEGORY_ORDER,
+  FURNITURE,
+  FURNITURE_SUBCATEGORY_LABELS,
+  FURNITURE_SUBCATEGORY_ORDER,
+  type I18nCatalogId,
+} from "@nodaro/shared"
+import { SETTINGS, SETTING_CATEGORY_LABELS } from "./setting.js"
+import { MATERIALS, MATERIAL_CATEGORY_LABELS, MATERIAL_CATEGORY_ORDER } from "./materials.js"
+import { ATMOSPHERES } from "./atmosphere.js"
+import { STYLES } from "./style.js"
+import { MOODS, MOOD_CATEGORY_LABELS, MOOD_CATEGORY_ORDER } from "./mood.js"
+import { POSES, POSE_CATEGORY_LABELS, POSE_CATEGORY_ORDER } from "./pose.js"
+import { CAMERA_MOTIONS, CAMERA_MOTION_CATEGORY_LABELS, CAMERA_MOTION_CATEGORY_ORDER } from "./camera-motions.js"
+import { LENSES } from "./lens.js"
+import { CAMERA_FORMATS } from "./camera-format.js"
+import { COLOR_LOOKS, COLOR_LOOK_CATEGORY_LABELS, COLOR_LOOK_CATEGORY_ORDER } from "./color-look.js"
+import { PHOTOGRAPHERS, PHOTOGRAPHER_CATEGORY_LABELS, PHOTOGRAPHER_CATEGORY_ORDER } from "./photographer.js"
+import { AESTHETICS, AESTHETIC_CATEGORY_LABELS, AESTHETIC_CATEGORY_ORDER } from "./aesthetic.js"
+import { ERAS, ERA_CATEGORY_LABELS, ERA_CATEGORY_ORDER } from "./era.js"
+import { PHOTO_GENRES, PHOTO_GENRE_CATEGORY_LABELS, PHOTO_GENRE_CATEGORY_ORDER } from "./photo-genre.js"
+import { BACKDROPS, BACKDROP_CATEGORY_LABELS, BACKDROP_CATEGORY_ORDER } from "./backdrop.js"
+import { HELD_PROPS, HELD_PROP_CATEGORY_LABELS, HELD_PROP_CATEGORY_ORDER } from "./held-prop.js"
+import { RENDER_QUALITIES } from "./render-quality.js"
+import { COMPOSITION_EFFECTS } from "./composition-effects.js"
+import { POST_PROCESS_EFFECTS } from "./post-process-effects.js"
+import { ACTION_FX, ACTION_FX_CATEGORY_LABELS, ACTION_FX_CATEGORY_ORDER } from "./action-fx.js"
+import { LOOP_SUBJECTS, LOOP_SUBJECT_CATEGORY_LABELS, LOOP_SUBJECT_CATEGORY_ORDER } from "./loop-subject.js"
+import { TRANSITIONS, TRANSITION_CATEGORY_LABELS, TRANSITION_CATEGORY_ORDER } from "./transitions.js"
+import { CHARACTER_FX, CHARACTER_FX_CATEGORY_LABELS, CHARACTER_FX_CATEGORY_ORDER } from "./character-fx.js"
+import { FRAMINGS, FRAMING_CATEGORY_ORDER, FRAMING_FIELD_BY_CATEGORY } from "./framing.js"
+import { LIGHTINGS, LIGHTING_CATEGORY_ORDER, LIGHTING_FIELD_BY_CATEGORY } from "./lighting.js"
+import { STYLINGS, STYLING_DIMENSION_ORDER, STYLING_FIELD_BY_DIMENSION } from "./styling.js"
+import { PEOPLE, PERSON_DIMENSION_ORDER, PERSON_FIELD_BY_DIMENSION } from "./person.js"
+import { TEMPORALS } from "./temporal.js"
+import { EXPOSURE_SETTINGS } from "./exposure-settings.js"
+import { MUSIC_GENRES, MUSIC_ERAS } from "./music-genre.js"
+import { MUSIC_ENERGIES, MUSIC_EMOTIONS, MUSIC_VIBES } from "./music-mood.js"
+import { INSTRUMENTS, PRODUCTION_STYLES, VOCAL_PRESENCE, SINGING_STYLES } from "./instrumentation.js"
+import { VOICE_AGES, VOICE_GENDERS, VOICE_LANGUAGES, VOICE_ACCENTS, VOICE_TIMBRES } from "./voice-character.js"
+import { VOICE_PACES, VOICE_EMOTIONS, VOICE_ARCHETYPES } from "./voice-delivery.js"
+
+/** One selectable catalog entry as picker UIs consume it. */
+export interface PickerWiringEntry {
+  readonly id: string
+  readonly label: string
+  readonly description: string
+  /** Optional group key for category headers. */
+  readonly group?: string
+}
+
+export interface SingleDimPickerWiring {
+  readonly kind: "single"
+  readonly nodeType: string
+  readonly label: string
+  readonly valueField: string
+  readonly defaultValue: string
+  readonly catalogId: I18nCatalogId
+  readonly entries: ReadonlyArray<PickerWiringEntry>
+  readonly groupOrder?: ReadonlyArray<string>
+  readonly groupLabels?: Readonly<Record<string, string>>
+}
+
+export interface MultiDimPickerWiring {
+  readonly kind: "multi"
+  readonly nodeType: string
+  readonly label: string
+  /** Data fields the picker reads/writes — used to slice node.data into a value object. */
+  readonly fields: ReadonlyArray<string>
+  readonly catalogId: I18nCatalogId
+  /** Flat id→label list — used to resolve ids into labels for summary chips. */
+  readonly catalogEntries: ReadonlyArray<{ readonly id: string; readonly label: string }>
+  /** Per-field option lists — lets a data-only consumer (community fallback,
+   *  Cine simple mode) render one select per field without knowing the
+   *  catalog's discriminator scheme. */
+  readonly fieldOptions: Readonly<Record<string, ReadonlyArray<{ readonly id: string; readonly label: string }>>>
+}
+
+export type PickerWiring = SingleDimPickerWiring | MultiDimPickerWiring
+
+function mapCat<T extends { id: string; label: string; description: string }>(
+  arr: ReadonlyArray<T>,
+  groupKey?: keyof T,
+): ReadonlyArray<PickerWiringEntry> {
+  return arr.map((e) => ({
+    id: e.id,
+    label: e.label,
+    description: e.description,
+    group: groupKey ? (e[groupKey] as unknown as string) : undefined,
+  }))
+}
+
+function flatCat<T extends { id: string; label: string }>(
+  arr: ReadonlyArray<T>,
+): ReadonlyArray<{ id: string; label: string }> {
+  return arr.map((e) => ({ id: e.id, label: e.label }))
+}
+
+/** Group a discriminated catalog into per-field option lists via key→field map. */
+function optionsByDiscriminator<T extends { id: string; label: string }>(
+  arr: ReadonlyArray<T>,
+  keyOf: (e: T) => string,
+  fieldByKey: Readonly<Record<string, string>>,
+): Record<string, Array<{ id: string; label: string }>> {
+  const out: Record<string, Array<{ id: string; label: string }>> = {}
+  for (const e of arr) {
+    const field = fieldByKey[keyOf(e)]
+    if (!field) continue
+    ;(out[field] ??= []).push({ id: e.id, label: e.label })
+  }
+  return out
+}
+
+export const SINGLE_PICKER_WIRING: ReadonlyArray<SingleDimPickerWiring> = [
+  // -------- "Look" family --------
+  { kind: "single", nodeType: "setting", label: "Setting", valueField: "setting", defaultValue: "forest", catalogId: "setting", entries: mapCat(SETTINGS, "category"), groupOrder: ["indoor", "urban", "nature", "fantastical"], groupLabels: SETTING_CATEGORY_LABELS },
+  { kind: "single", nodeType: "atmosphere", label: "Atmosphere", valueField: "atmosphere", defaultValue: "clear", catalogId: "atmosphere", entries: mapCat(ATMOSPHERES) },
+  { kind: "single", nodeType: "style", label: "Style", valueField: "style", defaultValue: "cinematic", catalogId: "style", entries: mapCat(STYLES) },
+  { kind: "single", nodeType: "color-look", label: "Color / Look", valueField: "colorLook", defaultValue: "warm", catalogId: "color-look", entries: mapCat(COLOR_LOOKS, "category"), groupOrder: COLOR_LOOK_CATEGORY_ORDER as ReadonlyArray<string>, groupLabels: COLOR_LOOK_CATEGORY_LABELS as Record<string, string> },
+  { kind: "single", nodeType: "mood", label: "Mood", valueField: "mood", defaultValue: "calm", catalogId: "mood", entries: mapCat(MOODS, "category"), groupOrder: MOOD_CATEGORY_ORDER as ReadonlyArray<string>, groupLabels: MOOD_CATEGORY_LABELS },
+  { kind: "single", nodeType: "photographer", label: "Photographer / Artist", valueField: "photographer", defaultValue: "tim-walker", catalogId: "photographer", entries: mapCat(PHOTOGRAPHERS, "category"), groupOrder: PHOTOGRAPHER_CATEGORY_ORDER as ReadonlyArray<string>, groupLabels: PHOTOGRAPHER_CATEGORY_LABELS },
+  { kind: "single", nodeType: "aesthetic", label: "Aesthetic / Microtrend", valueField: "aesthetic", defaultValue: "y2k", catalogId: "aesthetic", entries: mapCat(AESTHETICS, "category"), groupOrder: AESTHETIC_CATEGORY_ORDER as ReadonlyArray<string>, groupLabels: AESTHETIC_CATEGORY_LABELS },
+  { kind: "single", nodeType: "era", label: "Era / Period", valueField: "era", defaultValue: "1990s-mall", catalogId: "era", entries: mapCat(ERAS, "category"), groupOrder: ERA_CATEGORY_ORDER as ReadonlyArray<string>, groupLabels: ERA_CATEGORY_LABELS },
+  { kind: "single", nodeType: "photo-genre", label: "Photo Genre", valueField: "photoGenre", defaultValue: "fashion-editorial", catalogId: "photo-genre", entries: mapCat(PHOTO_GENRES, "category"), groupOrder: PHOTO_GENRE_CATEGORY_ORDER as ReadonlyArray<string>, groupLabels: PHOTO_GENRE_CATEGORY_LABELS },
+  { kind: "single", nodeType: "backdrop", label: "Backdrop", valueField: "backdrop", defaultValue: "white-seamless", catalogId: "backdrop", entries: mapCat(BACKDROPS, "category"), groupOrder: BACKDROP_CATEGORY_ORDER as ReadonlyArray<string>, groupLabels: BACKDROP_CATEGORY_LABELS },
+  { kind: "single", nodeType: "render-quality", label: "Render Quality", valueField: "renderQuality", defaultValue: "raytracing", catalogId: "render-quality", entries: mapCat(RENDER_QUALITIES) },
+  { kind: "single", nodeType: "composition-effects", label: "Composition Effect", valueField: "compositionEffect", defaultValue: "bursting-through-frame", catalogId: "composition-effects", entries: mapCat(COMPOSITION_EFFECTS) },
+  { kind: "single", nodeType: "action-fx", label: "Action FX", valueField: "actionFx", defaultValue: "earthquake-tremor", catalogId: "action-fx", entries: mapCat(ACTION_FX, "category"), groupOrder: ACTION_FX_CATEGORY_ORDER as ReadonlyArray<string>, groupLabels: ACTION_FX_CATEGORY_LABELS as Record<string, string> },
+  { kind: "single", nodeType: "loop-subject", label: "Loop Subject", valueField: "loopSubject", defaultValue: "tunnel", catalogId: "loop-subject", entries: mapCat(LOOP_SUBJECTS, "category"), groupOrder: LOOP_SUBJECT_CATEGORY_ORDER as ReadonlyArray<string>, groupLabels: LOOP_SUBJECT_CATEGORY_LABELS as Record<string, string> },
+  { kind: "single", nodeType: "post-process-effects", label: "Post-Process Effect", valueField: "postProcess", defaultValue: "vignette-soft", catalogId: "post-process-effects", entries: mapCat(POST_PROCESS_EFFECTS) },
+
+  // -------- "Camera" family --------
+  { kind: "single", nodeType: "camera-motion", label: "Camera Motion", valueField: "cameraMotion", defaultValue: "static", catalogId: "camera-motions", entries: mapCat(CAMERA_MOTIONS, "category"), groupOrder: CAMERA_MOTION_CATEGORY_ORDER as ReadonlyArray<string>, groupLabels: CAMERA_MOTION_CATEGORY_LABELS },
+  { kind: "single", nodeType: "lens", label: "Lens", valueField: "lens", defaultValue: "normal-50mm", catalogId: "lens", entries: mapCat(LENSES) },
+  { kind: "single", nodeType: "camera-format", label: "Camera / Film", valueField: "cameraFormat", defaultValue: "35mm-film", catalogId: "camera-format", entries: mapCat(CAMERA_FORMATS) },
+  { kind: "single", nodeType: "transition", label: "Transition", valueField: "transition", defaultValue: "auto", catalogId: "transitions", entries: mapCat(TRANSITIONS, "category"), groupOrder: TRANSITION_CATEGORY_ORDER as ReadonlyArray<string>, groupLabels: TRANSITION_CATEGORY_LABELS },
+  { kind: "single", nodeType: "character-fx", label: "Character FX", valueField: "characterFx", defaultValue: "auto", catalogId: "character-fx", entries: mapCat(CHARACTER_FX, "category"), groupOrder: CHARACTER_FX_CATEGORY_ORDER as ReadonlyArray<string>, groupLabels: CHARACTER_FX_CATEGORY_LABELS },
+
+  // -------- "Subject / Object" family --------
+  { kind: "single", nodeType: "pose", label: "Pose", valueField: "pose", defaultValue: "standing-upright", catalogId: "pose", entries: mapCat(POSES, "category"), groupOrder: POSE_CATEGORY_ORDER as ReadonlyArray<string>, groupLabels: POSE_CATEGORY_LABELS },
+  { kind: "single", nodeType: "material", label: "Material", valueField: "material", defaultValue: "silk", catalogId: "materials", entries: mapCat(MATERIALS, "category"), groupOrder: MATERIAL_CATEGORY_ORDER as ReadonlyArray<string>, groupLabels: MATERIAL_CATEGORY_LABELS },
+  { kind: "single", nodeType: "animal", label: "Animal", valueField: "animal", defaultValue: "dog-golden-retriever", catalogId: "animals", entries: mapCat(ANIMALS, "subcategory"), groupOrder: ANIMAL_SUBCATEGORY_ORDER as ReadonlyArray<string>, groupLabels: ANIMAL_SUBCATEGORY_LABELS },
+  { kind: "single", nodeType: "vehicle", label: "Vehicle", valueField: "vehicle", defaultValue: "sedan", catalogId: "vehicles", entries: mapCat(VEHICLES, "subcategory"), groupOrder: VEHICLE_SUBCATEGORY_ORDER as ReadonlyArray<string>, groupLabels: VEHICLE_SUBCATEGORY_LABELS },
+  { kind: "single", nodeType: "weapon", label: "Weapon", valueField: "weapon", defaultValue: "katana", catalogId: "weapons", entries: mapCat(WEAPONS, "subcategory"), groupOrder: WEAPON_SUBCATEGORY_ORDER as ReadonlyArray<string>, groupLabels: WEAPON_SUBCATEGORY_LABELS },
+  { kind: "single", nodeType: "furniture", label: "Furniture", valueField: "furniture", defaultValue: "sofa", catalogId: "furniture", entries: mapCat(FURNITURE, "subcategory"), groupOrder: FURNITURE_SUBCATEGORY_ORDER as ReadonlyArray<string>, groupLabels: FURNITURE_SUBCATEGORY_LABELS },
+  { kind: "single", nodeType: "held-prop", label: "Held Prop", valueField: "heldProp", defaultValue: "smartphone", catalogId: "held-prop", entries: mapCat(HELD_PROPS, "category"), groupOrder: HELD_PROP_CATEGORY_ORDER as ReadonlyArray<string>, groupLabels: HELD_PROP_CATEGORY_LABELS },
+]
+
+// Derived from the canonical dimension/category order + field map (same source
+// the picker components and the describe-to-picker analyzer use). Deriving
+// (not hand-listing) means these can never drift from the node-data shape.
+const STYLING_FIELDS = STYLING_DIMENSION_ORDER.map((d) => STYLING_FIELD_BY_DIMENSION[d])
+const PERSON_FIELDS = PERSON_DIMENSION_ORDER.map((d) => PERSON_FIELD_BY_DIMENSION[d])
+const LIGHTING_FIELDS = LIGHTING_CATEGORY_ORDER.map((c) => LIGHTING_FIELD_BY_CATEGORY[c])
+
+// Literal category→field maps for the two catalogs whose discriminators don't
+// ship a shared FIELD_BY map (kept tiny + local; a wrong key = the field
+// silently missing from fieldOptions, which the wiring guard test catches).
+const TEMPORAL_FIELD_BY_CATEGORY: Readonly<Record<string, string>> = {
+  speed: "temporalSpeed",
+  freeze: "temporalFreeze",
+  direction: "temporalDirection",
+  shutter: "temporalShutter",
+}
+const EXPOSURE_FIELD_BY_CATEGORY: Readonly<Record<string, string>> = {
+  aperture: "aperture",
+  "shutter-speed": "shutterSpeed",
+  iso: "isoValue",
+}
+
+export const MULTI_PICKER_WIRING: ReadonlyArray<MultiDimPickerWiring> = [
+  {
+    kind: "multi",
+    nodeType: "framing",
+    label: "Framing",
+    fields: ["shotSize", "angle", "coverage", "composition", "vantage"],
+    catalogId: "framing",
+    catalogEntries: flatCat(FRAMINGS),
+    fieldOptions: optionsByDiscriminator(FRAMINGS, (e) => e.category, FRAMING_FIELD_BY_CATEGORY as Readonly<Record<string, string>>),
+  },
+  {
+    kind: "multi",
+    nodeType: "lighting",
+    label: "Lighting",
+    fields: LIGHTING_FIELDS,
+    catalogId: "lighting",
+    catalogEntries: flatCat(LIGHTINGS),
+    fieldOptions: optionsByDiscriminator(LIGHTINGS, (e) => e.category, LIGHTING_FIELD_BY_CATEGORY as Readonly<Record<string, string>>),
+  },
+  {
+    kind: "multi",
+    nodeType: "person",
+    label: "Person",
+    fields: PERSON_FIELDS,
+    catalogId: "person",
+    catalogEntries: flatCat(PEOPLE),
+    fieldOptions: optionsByDiscriminator(PEOPLE, (e) => e.dimension, PERSON_FIELD_BY_DIMENSION as Readonly<Record<string, string>>),
+  },
+  {
+    kind: "multi",
+    nodeType: "styling",
+    label: "Styling",
+    fields: STYLING_FIELDS,
+    catalogId: "styling",
+    catalogEntries: flatCat(STYLINGS),
+    fieldOptions: optionsByDiscriminator(STYLINGS, (e) => e.dimension, STYLING_FIELD_BY_DIMENSION as Readonly<Record<string, string>>),
+  },
+  {
+    kind: "multi",
+    nodeType: "temporal",
+    label: "Temporal",
+    fields: ["temporalSpeed", "temporalFreeze", "temporalDirection", "temporalShutter"],
+    catalogId: "temporal",
+    catalogEntries: flatCat(TEMPORALS),
+    fieldOptions: optionsByDiscriminator(TEMPORALS, (e) => e.category, TEMPORAL_FIELD_BY_CATEGORY),
+  },
+  {
+    kind: "multi",
+    nodeType: "exposure-settings",
+    label: "Exposure Settings",
+    fields: ["aperture", "shutterSpeed", "isoValue"],
+    catalogId: "exposure-settings",
+    catalogEntries: flatCat(EXPOSURE_SETTINGS),
+    fieldOptions: optionsByDiscriminator(EXPOSURE_SETTINGS, (e) => e.category, EXPOSURE_FIELD_BY_CATEGORY),
+  },
+  // -------- "Sound" family --------
+  // Music Genre catalog is hierarchical: flatten genres + every subgenre +
+  // eras so summary chips can resolve any selected id back to a human label.
+  {
+    kind: "multi",
+    nodeType: "music-genre",
+    label: "Music Genre",
+    fields: ["genre", "subgenre", "era"],
+    catalogId: "music-genre",
+    catalogEntries: [
+      ...flatCat(MUSIC_GENRES),
+      ...MUSIC_GENRES.flatMap((g) => g.subgenres.map((s) => ({ id: s.id, label: s.label }))),
+      ...flatCat(MUSIC_ERAS),
+    ],
+    fieldOptions: {
+      genre: flatCat(MUSIC_GENRES),
+      subgenre: MUSIC_GENRES.flatMap((g) => g.subgenres.map((s) => ({ id: s.id, label: s.label }))),
+      era: flatCat(MUSIC_ERAS),
+    },
+  },
+  {
+    kind: "multi",
+    nodeType: "music-mood",
+    label: "Music Mood",
+    fields: ["energy", "emotion", "vibe"],
+    catalogId: "music-mood",
+    catalogEntries: [...flatCat(MUSIC_ENERGIES), ...flatCat(MUSIC_EMOTIONS), ...flatCat(MUSIC_VIBES)],
+    fieldOptions: {
+      energy: flatCat(MUSIC_ENERGIES),
+      emotion: flatCat(MUSIC_EMOTIONS),
+      vibe: flatCat(MUSIC_VIBES),
+    },
+  },
+  {
+    kind: "multi",
+    nodeType: "instrumentation",
+    label: "Instrumentation",
+    fields: ["instruments", "production", "vocalPresence", "singingStyle"],
+    catalogId: "instrumentation",
+    catalogEntries: [...flatCat(INSTRUMENTS), ...flatCat(PRODUCTION_STYLES), ...flatCat(VOCAL_PRESENCE), ...flatCat(SINGING_STYLES)],
+    fieldOptions: {
+      instruments: flatCat(INSTRUMENTS),
+      production: flatCat(PRODUCTION_STYLES),
+      vocalPresence: flatCat(VOCAL_PRESENCE),
+      singingStyle: flatCat(SINGING_STYLES),
+    },
+  },
+  {
+    kind: "multi",
+    nodeType: "voice-character",
+    label: "Voice Character",
+    fields: ["age", "gender", "language", "accent", "timbre"],
+    catalogId: "voice-character",
+    catalogEntries: [...flatCat(VOICE_AGES), ...flatCat(VOICE_GENDERS), ...flatCat(VOICE_LANGUAGES), ...flatCat(VOICE_ACCENTS), ...flatCat(VOICE_TIMBRES)],
+    fieldOptions: {
+      age: flatCat(VOICE_AGES),
+      gender: flatCat(VOICE_GENDERS),
+      language: flatCat(VOICE_LANGUAGES),
+      accent: flatCat(VOICE_ACCENTS),
+      timbre: flatCat(VOICE_TIMBRES),
+    },
+  },
+  {
+    kind: "multi",
+    nodeType: "voice-delivery",
+    label: "Voice Delivery",
+    fields: ["pace", "emotion", "archetype"],
+    catalogId: "voice-delivery",
+    catalogEntries: [...flatCat(VOICE_PACES), ...flatCat(VOICE_EMOTIONS), ...flatCat(VOICE_ARCHETYPES)],
+    fieldOptions: {
+      pace: flatCat(VOICE_PACES),
+      emotion: flatCat(VOICE_EMOTIONS),
+      archetype: flatCat(VOICE_ARCHETYPES),
+    },
+  },
+]
+
+export const ALL_PICKER_WIRING: ReadonlyArray<PickerWiring> = [
+  ...SINGLE_PICKER_WIRING,
+  ...MULTI_PICKER_WIRING,
+]
+
+const WIRING_MAP = new Map<string, PickerWiring>(ALL_PICKER_WIRING.map((w) => [w.nodeType, w]))
+
+export function getPickerWiring(nodeType: string | undefined | null): PickerWiring | undefined {
+  if (!nodeType) return undefined
+  return WIRING_MAP.get(nodeType)
+}

package/src/prompt-wizard-categories.ts

@@ -242,6 +242,8 @@ export const PROVIDER_CAPABILITIES: Record<string, Record<string, string>> = {
     "seedance-2": "Seedance 2.0 — multimodal refs (9 images / 3 videos / 3 audio), native multi-track audio, multi-shot storytelling, 4-15s",
     "seedance-2-fast": "Seedance 2.0 Fast — same multimodal + audio capabilities, cheaper and quicker",
     "seedance-2-mini": "Seedance 2.0 Mini — same multimodal + audio capabilities, budget tier, 480p/720p, 4-15s",
+    "seedance-2-5": "Seedance 2.5 — up to 30s in ONE shot (no stitching), wider multimodal refs (30 images / 10 videos / 10 audio), native audio, 480p/720p",
+    "minimax-h3": "MiniMax Hailuo 3 — premium multimodal refs (9 images / 3 videos / 3 audio), always-on audio, 2K or 768P, 4-15s per-second pricing",
     "wan": "Versatile, good for animations and transformations",
     "wan-turbo": "Faster Wan generation",
     "hailuo-standard": "Standard quality, cost-effective",
@@ -268,6 +270,8 @@ export const PROVIDER_CAPABILITIES: Record<string, Record<string, string>> = {
     "seedance-2": "Seedance 2.0 — start/end frame + multimodal refs, native audio, 4-15s",
     "seedance-2-fast": "Seedance 2.0 Fast — same capabilities, cheaper and quicker",
     "seedance-2-mini": "Seedance 2.0 Mini — same capabilities, budget tier, 480p/720p",
+    "seedance-2-5": "Seedance 2.5 — start/end frame + wide multimodal refs, native audio, up to 30s, 480p/720p",
+    "minimax-h3": "MiniMax Hailuo 3 — first/last frame + multimodal refs, always-on audio, 2K or 768P, 4-15s",
     "hailuo-2.3-pro": "Premium Hailuo animation",
     "hailuo-2.3": "Standard Hailuo animation",
     "hailuo-standard": "Cost-effective animation",