@nodaro/shared 2.1.0 → 2.2.0

package/src/model-constants.ts

@@ -89,11 +89,17 @@ export const SUNO_TEXT_MAX = 5000
  * video routes' Zod schemas. The PER-MODEL limits below (and the editor warning)
  * do the real work; the routes stay generous so they never hard-reject a legit
  * long prompt — the assembler/payload truncates to the model cap as a graceful
- * safety net (warn-don't-block). 20000 = the largest verified per-model image/
- * video limit (seedance-2 / nano-banana-2 / gemini-omni). Anything past this is
- * abuse, not a real prompt.
+ * safety net (warn-don't-block). 30000 = the largest verified per-model image/
+ * video limit (seedance-2-5; seedance-2 / nano-banana-2 / gemini-omni sit at
+ * 20000). Anything past this is abuse, not a real prompt.
+ *
+ * This MUST stay >= the largest entry in MAX_VIDEO_PROMPT_CHARS_BY_PROVIDER /
+ * MAX_IMAGE_PROMPT_CHARS_BY_PROVIDER — otherwise the route's Zod hard-rejects a
+ * prompt the model itself would have accepted, which is exactly the
+ * block-instead-of-warn behaviour this ceiling exists to avoid. A drift guard in
+ * `__tests__/prompt-length-limits.test.ts` enforces that relationship.
  */
-export const PROMPT_HARD_CEILING = 20000
+export const PROMPT_HARD_CEILING = 30000
 
 /**
  * Ceiling for LLM TEXT-generation node inputs (the "Generate Text"/llm-chat node
@@ -129,10 +135,16 @@ export const MAX_VIDEO_PROMPT_CHARS_BY_PROVIDER: Record<string, number> = {
   "seedance-2-fast": 20000,
   "seedance-2-mini": 20000,
   "seedance-2-extend": 20000,
+  // Seedance 2.5 raises the prompt ceiling to 30000
+  // (docs.kie.ai/market/bytedance/seedance-2-5).
+  "seedance-2-5": 30000,
   "gemini-omni-video": 20000,
   "bytedance-lite": 10000,
   "bytedance-pro": 10000,
   "bytedance-pro-fast": 10000,
+  // MiniMax Hailuo 3 — 1-7000 chars, uniform across t2v/i2v/r2v
+  // (docs.kie.ai/market/minimax-h3).
+  "minimax-h3": 7000,
   // lower than the 8000 default
   "minimax": 1500,
   "hailuo-standard": 1500,
@@ -641,6 +653,8 @@ export const IMAGE_TO_VIDEO_PROVIDERS = [
   "seedance-2",
   "seedance-2-fast",
   "seedance-2-mini",
+  "seedance-2-5",
+  "minimax-h3",
   "hailuo-2.3-pro",
   "hailuo-2.3",
   "hailuo-standard",
@@ -683,6 +697,8 @@ export const TEXT_TO_VIDEO_PROVIDERS = [
   "seedance-2",
   "seedance-2-fast",
   "seedance-2-mini",
+  "seedance-2-5",
+  "minimax-h3",
   "wan",
   "hailuo-standard",
   "bytedance-lite",
@@ -861,15 +877,24 @@ export const LIP_SYNC_PROVIDERS = [
   "seedance-2",
   "seedance-2-fast",
   "seedance-2-mini",
+  "seedance-2-5",
+  // MiniMax Hailuo 3 — same multimodal audio-driven mechanism (r2v
+  // reference_audio_urls paired with an image ref); rides the same
+  // reference-audio lip-sync surface as the Seedance 2 family.
+  "minimax-h3",
 ] as const
 export type LipSyncProvider = typeof LIP_SYNC_PROVIDERS[number]
 
-/** Seedance variants exposed via the lip-sync surface. They go through
- *  the i2v provider with the audio plumbed as `reference_audio_urls`. */
+/** Multimodal video models exposed via the lip-sync surface (Seedance 2 family
+ *  + MiniMax Hailuo 3). They go through the i2v provider with the audio
+ *  plumbed as `reference_audio_urls` rather than a dedicated lip-sync flow.
+ *  (Name kept for the Seedance-era public export.) */
 export const SEEDANCE_LIP_SYNC_PROVIDERS = new Set<string>([
   "seedance-2",
   "seedance-2-fast",
   "seedance-2-mini",
+  "seedance-2-5",
+  "minimax-h3",
 ])
 
 /** Replicate-based lip-sync providers (video or image+audio via Replicate SDK) */
@@ -1104,6 +1129,8 @@ export const DURATION_PRICED_PROVIDERS = new Set([
   "seedance-2",
   "seedance-2-fast",
   "seedance-2-mini",
+  "seedance-2-5",
+  "minimax-h3",
   "grok-imagine-video-1.5",
   "happyhorse",
   "happyhorse-i2v",
@@ -1118,6 +1145,12 @@ export const SEEDANCE_2_PROVIDERS = new Set<string>([
   "seedance-2",
   "seedance-2-fast",
   "seedance-2-mini",
+  // Seedance 2.5 — a later generation, but it shares the whole 2.0 capability
+  // surface this set gates (frames + image/video/audio refs, adaptive aspect,
+  // per-second resolution × video-ref pricing), so it belongs here. Where it
+  // DIFFERS (30s ceiling, no 1080p/4K, wider ref caps) the difference is
+  // carried by the per-provider maps, never by branching on this set.
+  "seedance-2-5",
 ])
 
 export function isSeedance2Provider(provider: string | undefined): boolean {
@@ -1125,21 +1158,278 @@ export function isSeedance2Provider(provider: string | undefined): boolean {
 }
 
 /**
- * Generate/Edit Video Pro SUPPORT subset — the only SKUs the pro multi-segment
- * engine currently offers (mini withdrawn from selection, 2026-07-21).
- * Deliberately distinct from SEEDANCE_2_PROVIDERS: the family set gates
- * CAPABILITIES (ref limits, i2v params, adaptive aspect) and must keep every
- * variant; this list gates which SKUs the pro nodes offer in selection. The
- * pro plugin routes stay tolerant of the full family so previously-saved
- * workflows keep running — the editor fail-safe snaps stale selections to a
- * supported SKU instead.
+ * MiniMax Hailuo 3 family — the KIE "minimax-h3" market model. One Nodaro id
+ * covers three KIE endpoints (text-to-video / image-to-video /
+ * reference-to-video); the provider layer swaps the endpoint by which inputs
+ * are present. Mirrors the Seedance 2 multimodal surface (frames + image/video/
+ * audio references) with a two-rate resolution lever (2K default / 768P,
+ * added 2026-08-03) and per-second pricing at the selected resolution's rate.
+ * Exact-membership set — NEVER match on a "minimax" prefix (the unrelated
+ * Hailuo 02 id "minimax" would collide).
+ */
+export const MINIMAX_H3_PROVIDERS = new Set<string>([
+  "minimax-h3",
+])
+
+export function isMinimaxH3Provider(provider: string | undefined): boolean {
+  return !!provider && MINIMAX_H3_PROVIDERS.has(provider)
+}
+
+/** MiniMax Hailuo 3 resolution the model renders when the param is omitted or
+ *  unknown — the KIE-side default. */
+export const MINIMAX_H3_DEFAULT_RESOLUTION = "2K"
+
+/**
+ * SINGLE normalization for the MiniMax Hailuo 3 resolution lever (KIE wire
+ * enum "768P" | "2K", default 2K) — shared by billing (credit-identifier
+ * suffix, r2v compute hook, GVP per-second anchor) and the provider layer's
+ * KIE forwarding. Only a case-insensitive "768p" selects the cheaper tier;
+ * ANYTHING else (undefined, a stale Seedance "720p", garbage) collapses to
+ * "2K" — exactly what KIE renders when the param is omitted/unknown, so the
+ * billed tier can never undercut the rendered one.
+ */
+export function normalizeMinimaxH3Resolution(resolution: string | undefined): "768P" | "2K" {
+  return resolution?.trim().toLowerCase() === "768p" ? "768P" : MINIMAX_H3_DEFAULT_RESOLUTION
+}
+
+/**
+ * Video models that are CATALOGUED and priced but have NO working dispatch
+ * path today — selecting one fails at the router, not at validation.
+ *
+ * `kling-3-omni` has a Replicate implementation but the i2v routing chain is
+ * KIE-only and it has no worker short-circuit (the way LTX does), so every run
+ * failed at the router. It was pulled from the frontend picker for that
+ * reason; the backend enum and cost rows stay so legacy saved workflows still
+ * validate.
+ *
+ * This lives in shared rather than as a comment in the frontend picker list
+ * because it is a REAL capability fact that more than one consumer must
+ * respect: `deriveGvpSupportedProviders` below would otherwise offer
+ * `kling-3-omni` (it is i2v, takes reference images, declares durations, and
+ * carries ref limits — it passes every capability check) and every selection
+ * would fail at run time.
+ *
+ * Remove an entry only after wiring its dispatch AND verifying a live
+ * generation.
+ */
+export const VIDEO_PROVIDERS_WITHOUT_DISPATCH = new Set<string>([
+  "kling-3-omni",
+])
+
+/** The SKU a stale/unsupported generate-video-pro selection snaps back to, and
+ *  the one that lists first in every pro provider dropdown. */
+export const GVP_DEFAULT_PROVIDER = "seedance-2"
+
+/**
+ * Generate Video Pro SUPPORT set — DERIVED FROM CAPABILITY, never hand-kept
+ * (2026-08-05; was a literal `["seedance-2","seedance-2-fast","minimax-h3"]`).
+ *
+ * The bar is exactly what the pro engine's KEYFRAMES render method needs: the
+ * model must accept a generated start still, and it must be able to carry the
+ * identity/continuity reference images the anchor wave and the extend chain
+ * attach. So:
+ *
+ *   kind "video" ∧ modes ∋ "i2v" ∧ features ∋ "reference-image" ∧ has durations
+ *
+ * `durations` is part of the bar because the engine SPLITS a request into
+ * segments — a model that declares no duration set cannot be segmented, and a
+ * silent 4–15s fallback would send lengths the provider rejects.
+ *
+ * Membership is cross-checked against `VIDEO_REF_LIMITS_BY_PROVIDER` below by
+ * `__tests__/gvp-supported-providers.test.ts`: that map was built by the
+ * 2026-06-28 audit of actual backend reference-FORWARDING paths, so a model
+ * carrying the catalog flag without a forwarding path (or vice versa) fails
+ * the build instead of silently advertising a capability the backend drops.
+ *
+ * Deliberately distinct from SEEDANCE_2_PROVIDERS, which gates CAPABILITIES
+ * (ref limits, i2v params, adaptive aspect) for the whole family. The pro
+ * plugin route stays tolerant of previously-saved values so in-flight
+ * workflows keep running; the editor fail-safe snaps stale selections to
+ * GVP_DEFAULT_PROVIDER instead.
+ *
+ * `seedance-2-mini` re-enters selection here (it was withdrawn by hand on
+ * 2026-07-21). It qualifies on capability and is the cheapest Seedance-2 SKU,
+ * which makes it the natural pick for cheap iteration on long runs.
  */
-export const GVP_SUPPORTED_PROVIDERS = ["seedance-2", "seedance-2-fast"] as const
+function deriveGvpSupportedProviders(): VideoGenProvider[] {
+  const dispatchable = new Set<string>(VIDEO_GEN_PROVIDERS as readonly string[])
+  const eligible = Object.values(MODEL_CATALOG)
+    .filter(
+      (m) =>
+        m.kind === "video" &&
+        (m.modes as readonly string[]).includes("i2v") &&
+        m.features?.includes("reference-image") === true &&
+        (m.durations?.length ?? 0) > 0 &&
+        // Must also be dispatchable by the unified video node — the pro route
+        // hands the provider id straight to the app's imageToVideo.
+        dispatchable.has(m.id) &&
+        // ...and must actually REACH a provider. Capability alone is not
+        // enough: kling-3-omni passes every check above and still fails at the
+        // router (see VIDEO_PROVIDERS_WITHOUT_DISPATCH).
+        !VIDEO_PROVIDERS_WITHOUT_DISPATCH.has(m.id),
+    )
+    .map((m) => m.id as VideoGenProvider)
+
+  // Dropdown order: SKUs of one model family stay adjacent (raw catalog order
+  // interleaves them — minimax-h3 is authored ~340 lines above seedance-2, so
+  // a flat sort would split the Seedance trio around it). Group by `series`,
+  // order groups by first catalog appearance, then hoist the default's group —
+  // and the default within it — to the front.
+  const seriesOf = (id: string): string => MODEL_CATALOG[id]?.series ?? MODEL_CATALOG[id]?.family ?? id
+  const defaultSeries = seriesOf(GVP_DEFAULT_PROVIDER)
+  const order: string[] = []
+  for (const id of eligible) {
+    const s = seriesOf(id)
+    if (!order.includes(s)) order.push(s)
+  }
+  const rank = (id: string): number => {
+    const s = seriesOf(id)
+    return s === defaultSeries ? -1 : order.indexOf(s)
+  }
+  return [...eligible].sort((a, b) => {
+    const d = rank(a) - rank(b)
+    if (d !== 0) return d
+    if (a === GVP_DEFAULT_PROVIDER) return -1
+    if (b === GVP_DEFAULT_PROVIDER) return 1
+    return eligible.indexOf(a) - eligible.indexOf(b)
+  })
+}
+
+export const GVP_SUPPORTED_PROVIDERS: readonly VideoGenProvider[] = deriveGvpSupportedProviders()
 
 export function isGvpSupportedProvider(provider: string | undefined): boolean {
   return !!provider && (GVP_SUPPORTED_PROVIDERS as readonly string[]).includes(provider)
 }
 
+/**
+ * The generate-video-pro SKUs whose transport supports the `extend` render
+ * method — a continuation TAIL of the previous segment sent as a conditioning
+ * reference video (KIE `reference_video_urls`, built by
+ * `resolveSeedance2Inputs`).
+ *
+ * Derived from the catalog's `"video-reference"` feature, so a future r2v SKU
+ * flows in on its own instead of needing a family predicate edited. Today this
+ * resolves to exactly the Seedance-2 family + minimax-h3 — identical to the
+ * hardcoded gate it replaces, so the change is behaviour-neutral.
+ *
+ * Every other blessed SKU renders `keyframes` only: each segment is generated
+ * from its own anchor stills, nothing conditions on another segment's video.
+ */
+export const GVP_EXTEND_PROVIDERS: readonly VideoGenProvider[] = GVP_SUPPORTED_PROVIDERS.filter(
+  (id) => MODEL_CATALOG[id]?.features?.includes("video-reference") === true,
+)
+
+export function supportsExtendRender(provider: string | undefined): boolean {
+  return !!provider && (GVP_EXTEND_PROVIDERS as readonly string[]).includes(provider)
+}
+
+/**
+ * The generate-video-pro SKUs that honour a strict CLOSING frame, so the
+ * keyframes anchor wave generates an end still for them as well as a start
+ * still. Derived from the catalog's `"end-frame"` feature — the plugin's
+ * `wantEndAnchor` reads this instead of a provider-family name check.
+ */
+export const GVP_END_FRAME_PROVIDERS: readonly VideoGenProvider[] = GVP_SUPPORTED_PROVIDERS.filter(
+  (id) => MODEL_CATALOG[id]?.features?.includes("end-frame") === true,
+)
+
+export function supportsEndAnchor(provider: string | undefined): boolean {
+  return !!provider && (GVP_END_FRAME_PROVIDERS as readonly string[]).includes(provider)
+}
+
+/**
+ * KEYFRAMES ANCHOR CHOICE — how much a keyframes run pins its shots to
+ * pre-generated stills. The node stores this product vocabulary; the plugin
+ * wire speaks its own `anchorMode`, and `resolveGvpAnchorWire` is the SINGLE
+ * translation both send paths go through (canvas Run in `execute-node.ts` and
+ * the DAG's `payload-builder.ts`), so the two cannot disagree about what the
+ * user picked — the drift that left `renderMethod` unreachable from the canvas
+ * until 2026-08-05.
+ */
+export const GVP_ANCHOR_CHOICES = ["auto", "start-end", "start-only", "reference"] as const
+
+export type GvpAnchorChoice = (typeof GVP_ANCHOR_CHOICES)[number]
+
+/** The plugin engine's own chain-mode vocabulary. */
+export type GvpAnchorWireMode = "upfront" | "progressive" | "none"
+
+/**
+ * Translate the node's anchor choice into the plugin's `anchorMode` field.
+ *
+ * - `auto` (and absent/unknown) → `undefined`: send NOTHING, leaving the
+ *   engine's own default and env flags in charge exactly as they are for
+ *   callers predating this lever. Existing payloads stay byte-identical.
+ * - `start-end` → `upfront`: anchors pre-generated from plan text, and the
+ *   engine's own closing-frame policy applies (capability-gated, longer
+ *   scenes only). Today's shipped behaviour.
+ * - `start-only` → `progressive`: each start anchor is generated just-in-time
+ *   from the PREVIOUS render's real last frame, and no closing still is ever
+ *   pinned — so a shot can never warp its world to reach a pre-motion guess.
+ * - `reference` → `none`: no frame conditioning at all; identity/location
+ *   references plus the prompt carry the shot.
+ *
+ * Deliberately NOT emitting the per-segment `endAnchors` array: that is a
+ * per-scene lever whose natural home is a per-scene surface, and emitting it
+ * here would mean duplicating the plugin's `MAX_SEGMENTS` cap in this repo
+ * where nothing could keep the two in step.
+ */
+export function resolveGvpAnchorWire(choice: string | undefined): GvpAnchorWireMode | undefined {
+  switch (choice) {
+    case "start-end":
+      return "upfront"
+    case "start-only":
+      return "progressive"
+    case "reference":
+      return "none"
+    default:
+      return undefined
+  }
+}
+
+// ---------------------------------------------------------------------------
+// SEGMENT BOUNDS — pure catalog readers. The generate-video-pro splitter (in
+// three places: the plugin engine, the money closed-form, the UI estimate)
+// used to hardcode `{minSeg: 4, maxSeg: 15}`, which is only correct for the
+// Seedance-2 family. These are the single source every one of them reads.
+// ---------------------------------------------------------------------------
+
+/** Allowed single-segment durations (seconds, ascending) for a pro provider.
+ *  Empty for anything not in the catalog — callers treat that as ineligible
+ *  rather than falling back to a window the provider may reject. */
+export function segmentDurationsFor(provider: string | undefined): readonly number[] {
+  if (!provider) return []
+  return [...(MODEL_CATALOG[provider]?.durations ?? [])].sort((a, b) => a - b)
+}
+
+/** Shortest single segment the provider can render. 0 when unknown. */
+export function minSegmentSecFor(provider: string | undefined): number {
+  return segmentDurationsFor(provider)[0] ?? 0
+}
+
+/** Longest single segment the provider can render — the value above which a
+ *  request must split. 0 when unknown. */
+export function maxSegmentSecFor(provider: string | undefined): number {
+  const d = segmentDurationsFor(provider)
+  return d[d.length - 1] ?? 0
+}
+
+/** True when the provider's durations are every integer between its min and
+ *  max (Seedance-2 family, minimax-h3, kling-3-omni, happyhorse-ref2v). Those
+ *  can use the classic arithmetic splitter; sparse providers (veo3's 4/6/8,
+ *  grok-i2v's 6/10) need the discrete packer. */
+export function hasContiguousSegmentDurations(provider: string | undefined): boolean {
+  const d = segmentDurationsFor(provider)
+  if (d.length === 0) return false
+  return d.length === d[d.length - 1]! - d[0]! + 1
+}
+
+/** Most segments a run can hold for this provider at a given total cap — the
+ *  dynamic replacement for the old fixed 24. 0 when the provider is unknown. */
+export function maxSegmentsFor(provider: string | undefined, capSec: number): number {
+  const max = maxSegmentSecFor(provider)
+  return max > 0 ? Math.ceil(capSec / max) : 0
+}
+
 /**
  * Default aspect ratio for a video provider when the node carries no explicit
  * `aspectRatio`. Seedance 2.x defaults to `"adaptive"` (output matches the
@@ -1147,9 +1437,15 @@ export function isGvpSupportedProvider(provider: string | undefined): boolean {
  * historical `"16:9"`. Single source of truth so every run-default / display-
  * fallback site stays in lock-step (preview = run). Applies to ALL Seedance
  * modes incl. text-to-video — KIE accepts `adaptive` there too.
+ *
+ * MiniMax Hailuo 3 also defaults to `adaptive`: its r2v endpoint takes
+ * `adaptive` natively (the KIE default) and its i2v endpoint has no aspect
+ * param at all (inferred from the frame). Only the pure-t2v endpoint requires
+ * a concrete ratio — the KIE provider layer coerces `adaptive` → `16:9` there
+ * (see applyMinimaxH3Params in backend kie/video.ts).
  */
 export function defaultVideoAspectRatio(provider: string | undefined): string {
-  return isSeedance2Provider(provider) ? "adaptive" : "16:9"
+  return isSeedance2Provider(provider) || isMinimaxH3Provider(provider) ? "adaptive" : "16:9"
 }
 
 /**
@@ -1173,6 +1469,18 @@ export const SEEDANCE_2_REF_LIMITS = {
   audio: 3,
 } as const
 
+/**
+ * Seedance 2.5 raises every reference cap well above the 2.0 family's
+ * (docs.kie.ai/market/bytedance/seedance-2-5): 30 images, 10 videos, 10 audio.
+ * Kept as its own constant rather than widening {@link SEEDANCE_2_REF_LIMITS}
+ * so the 2.0 SKUs can't silently start advertising caps KIE rejects for them.
+ */
+export const SEEDANCE_2_5_REF_LIMITS = {
+  images: 30,
+  videos: 10,
+  audio: 10,
+} as const
+
 /**
  * KIE r2v REFERENCE-VIDEO MINIMUM (seconds) for the Seedance 2.0 family — the
  * provider hard-rejects shorter reference clips with a 400 BEFORE generation:
@@ -1233,6 +1541,12 @@ export const SEEDANCE_2_EXTEND_STITCH = {
  */
 export const SEEDANCE_2_R2V_MAX_AUDIO_SEC_BY_PROVIDER: Record<string, number> = {
   "seedance-2-fast": 15.2,
+  // Seedance 2.5 — documented hard limit: each reference audio 2-30s, ≤15 MB
+  // per file (docs.kie.ai/market/bytedance/seedance-2-5).
+  "seedance-2-5": 30,
+  // MiniMax Hailuo 3 — documented hard limit: each reference audio segment
+  // 2-15s, ≤15s total (docs.kie.ai/market/minimax-h3/reference-to-video).
+  "minimax-h3": 15,
 }
 
 /** The verified r2v reference-audio cap (seconds) for a provider, or null when
@@ -1281,6 +1595,13 @@ export const VIDEO_REF_LIMITS_BY_PROVIDER: Record<
   "seedance-2": { ...SEEDANCE_2_REF_LIMITS },
   "seedance-2-fast": { ...SEEDANCE_2_REF_LIMITS },
   "seedance-2-mini": { ...SEEDANCE_2_REF_LIMITS },
+  // Seedance 2.5 — wider caps than the 2.0 family (30 / 10 / 10).
+  "seedance-2-5": { ...SEEDANCE_2_5_REF_LIMITS },
+  // MiniMax Hailuo 3 — identical multimodal caps (9 images / 3 videos / 3
+  // audio per docs.kie.ai/market/minimax-h3/reference-to-video). Note: KIE
+  // bills input images beyond the first 5 (11 KIE cr each) — see the
+  // minimax-h3 credit helper in backend ee/billing.
+  "minimax-h3": { ...SEEDANCE_2_REF_LIMITS },
   // Multi-image reference providers.
   "gemini-omni-video": { images: 7, videos: 1 },
   "kling-3-omni": { images: 7 },     // catalog/docs: "end frame + up to 7 reference images"
@@ -1348,8 +1669,30 @@ export const NATIVE_ADAPTIVE_ASPECT: Record<string, string> = {
   "seedance-2": "adaptive",
   "seedance-2-fast": "adaptive",
   "seedance-2-mini": "adaptive",
+  "seedance-2-5": "adaptive",
 }
 
+/**
+ * Video providers that accept ONLY the "adaptive" aspect ratio once a START
+ * FRAME is present (first-frame or first+last-frame mode). Sending any explicit
+ * ratio in that mode is a hard 422 from the provider, so the payload builder
+ * coerces the value to `adaptive` for these instead of forwarding it.
+ *
+ * UNDOCUMENTED — KIE's schema advertises the full ratio enum unconditionally and
+ * only rejects the combination at request time:
+ *   "Seedance 2.5 first-frame and first-last-frame tasks only support adaptive
+ *    aspect ratio"
+ * (live probe against api.kie.ai, 2026-08-08). Verified as 2.5-ONLY: the same
+ * probe against the 2.0 SKUs accepts explicit ratios with a start frame, which
+ * is why this is a set and not a family-wide rule.
+ *
+ * Behaviourally this costs nothing — with a start frame the output aspect is
+ * derived from that frame anyway, which is exactly what `adaptive` means.
+ */
+export const FRAME_MODE_ADAPTIVE_ONLY_ASPECT: ReadonlySet<string> = new Set([
+  "seedance-2-5",
+])
+
 /**
  * Video providers that REQUIRE an input image (image-to-video only) even though
  * they're listed in TEXT_TO_VIDEO_PROVIDERS for unified-node visibility. The
@@ -1477,6 +1820,14 @@ export const VIDEO_AUDIO_CAPABILITY: Record<string, VideoAudioCapability> = {
   "seedance-2": { mode: "audio_driven", field: "generateAudio" },
   "seedance-2-fast": { mode: "audio_driven", field: "generateAudio" },
   "seedance-2-mini": { mode: "audio_driven", field: "generateAudio" },
+  // Seedance 2.5 — same audio-driven surface; `generate_audio` defaults TRUE
+  // on KIE and is cost-affecting only through the -ref/no-ref rate split,
+  // which the resolution+ref composite already carries (no `:audio` suffix).
+  "seedance-2-5": { mode: "audio_driven", field: "generateAudio", defaultOn: true },
+  // MiniMax Hailuo 3 — multimodal; lip-syncs to reference audio (r2v). The
+  // KIE API exposes NO audio on/off parameter (audio is always produced), so
+  // there is no toggle field — alwaysOn, like VEO.
+  "minimax-h3": { mode: "audio_driven", alwaysOn: true },
 }
 
 const VIDEO_AUDIO_NONE: VideoAudioCapability = { mode: "none" }
@@ -1595,10 +1946,51 @@ export const VIDEO_VARIABLE_PRICING: Record<string, "duration" | "duration+audio
   "seedance-2": "duration+resolution+ref",
   "seedance-2-fast": "duration+resolution+ref",
   "seedance-2-mini": "duration+resolution+ref",
+  "seedance-2-5": "duration+resolution+ref",
+  // MiniMax Hailuo 3 — per-second rate at two resolution tiers (2K default /
+  // 768P). Duration + resolution form the composite (bare = 2K, ":768p"
+  // appended for the cheaper tier); ref-video input seconds + extra input
+  // images are billed via the dedicated compute hook, not the identifier.
+  "minimax-h3": "duration+resolution",
   // Grok Imagine Video 1.5 — per-second billing split 480p/720p (no video-ref dimension).
   "grok-imagine-video-1.5": "duration+resolution",
 }
 
+/**
+ * Duration assumed for PRICING when a request names a provider but omits
+ * `duration` — MUST match the provider's KIE-side default (`extraParams.duration`
+ * in backend kie/models.ts) so an intent-less request reserves what it will
+ * actually render. Providers absent here use the historical global 5s fallback,
+ * which is only safe when their duration TIERS snap 5 up to (or past) the model
+ * default (e.g. seedance-2's 4/8/12/15 ladder snaps 5 → the 8s tier = its 8s
+ * default). minimax-h3 prices per-second (every 4-15s tier seeded), so a 5s
+ * fallback would under-reserve its 6s default render.
+ */
+export const PRICING_DEFAULT_DURATION_SEC: Record<string, number> = {
+  "minimax-h3": 6,
+}
+
+/**
+ * Resolution assumed for PRICING when a request names a provider but omits
+ * `resolution` — the resolution twin of {@link PRICING_DEFAULT_DURATION_SEC},
+ * and it MUST match the provider's KIE-side default (`extraParams.resolution`
+ * in backend kie/models.ts) so an intent-less request reserves what it will
+ * actually render.
+ *
+ * Without an entry, `buildVideoCreditModelIdentifier` falls back to the
+ * CHEAPEST tier (480p) for a resolution-priced provider. That is safe only for
+ * a model whose KIE default IS the cheapest tier; for one defaulting to 720p it
+ * reserves the 480p price against a 720p render, and `commit_credits` cannot
+ * collect the difference afterwards.
+ *
+ * Providers absent here keep the historical 480p fallback — deliberately, so
+ * adding this map cannot reprice anything already live.
+ */
+export const PRICING_DEFAULT_RESOLUTION: Record<string, string> = {
+  // KIE renders 720p when `resolution` is omitted (kie/models.ts extraParams).
+  "seedance-2-5": "720p",
+}
+
 /** HappyHorse 1.1 per-second tiers — one per allowed duration (3–15s), shared
  *  by all three modes (t2v/i2v/ref2v) which bill at identical published rates. */
 const HAPPYHORSE_DURATION_TIERS: Array<{ maxSeconds: number; suffix: string }> = Array.from(
@@ -1606,6 +1998,21 @@ const HAPPYHORSE_DURATION_TIERS: Array<{ maxSeconds: number; suffix: string }> =
   (_, i) => ({ maxSeconds: i + 3, suffix: `${i + 3}s` }),
 )
 
+/**
+ * Seedance 2.5 per-second tiers — one per allowed duration (4–30s), like
+ * minimax-h3 and unlike the 2.0 family's coarse 4/8/12/15 ladder.
+ *
+ * Per-second is REQUIRED here, not a nicety: the ladder snaps a request UP to
+ * the first tier whose `maxSeconds` covers it and falls back to the LAST tier
+ * when nothing does, so a coarse ladder over a 30s range would reserve the 15s
+ * price for a 30s render. `commit_credits` only ever refunds a surplus and can
+ * never collect an upward delta, so that under-reservation would be permanent.
+ */
+const SEEDANCE_2_5_DURATION_TIERS: Array<{ maxSeconds: number; suffix: string }> = Array.from(
+  { length: 27 },
+  (_, i) => ({ maxSeconds: i + 4, suffix: `${i + 4}s` }),
+)
+
 /**
  * Duration tier breakpoints for variable-priced video models.
  * Maps provider → array of { maxSeconds, suffix } in ascending order.
@@ -1685,6 +2092,25 @@ export const VIDEO_DURATION_TIERS: Record<string, Array<{ maxSeconds: number; su
     { maxSeconds: 12, suffix: "12s" },
     { maxSeconds: 15, suffix: "15s" },
   ],
+  "seedance-2-5": SEEDANCE_2_5_DURATION_TIERS,
+  // MiniMax Hailuo 3 — true per-second billing (KIE 36.5 cr/s @2K, 22.5 cr/s
+  // @768P). One tier per allowed second (4-15s) so the composite identifier
+  // maps 1:1 to the seeded price — no rounding/overcharge for any on-menu
+  // duration; the ":768p" resolution suffix is appended after the tier.
+  "minimax-h3": [
+    { maxSeconds: 4, suffix: "4s" },
+    { maxSeconds: 5, suffix: "5s" },
+    { maxSeconds: 6, suffix: "6s" },
+    { maxSeconds: 7, suffix: "7s" },
+    { maxSeconds: 8, suffix: "8s" },
+    { maxSeconds: 9, suffix: "9s" },
+    { maxSeconds: 10, suffix: "10s" },
+    { maxSeconds: 11, suffix: "11s" },
+    { maxSeconds: 12, suffix: "12s" },
+    { maxSeconds: 13, suffix: "13s" },
+    { maxSeconds: 14, suffix: "14s" },
+    { maxSeconds: 15, suffix: "15s" },
+  ],
   // Grok Imagine Video 1.5 — true per-second billing (KIE 14.5 cr/s @480p, 25 cr/s
   // @720p, +2 cr/image). One tier per allowed second (1–15s) so the composite
   // identifier maps 1:1 to the seeded price — no rounding/overcharge for any on-menu value.
@@ -1895,6 +2321,17 @@ export const VIDEO_MODEL_CAPS: Record<string, VideoModelCapabilities> = {
     // character + location + 3 secondary refs.
     maxReferenceImages: 5,
   },
+  "seedance-2-5": {
+    inputModes: ["first_frame", "first_last_frame", "ref_images", "video_continuation"],
+    supportsVideoExtension: true,
+    // 30s single-shot on KIE (probe-verified 2026-08-08: 30 accepted, 31 rejected).
+    maxDurationSeconds: 30,
+    prompting_style: "natural_language",
+    // SEEDANCE_2_5_REF_LIMITS.images is the hard upper bound (30); the same
+    // conservative headroom rule as seedance-2 applies to what the director
+    // actually allocates.
+    maxReferenceImages: 5,
+  },
   "hailuo-2.3-pro": {
     inputModes: ["first_frame", "text"],
     maxDurationSeconds: 10,

package/src/node-default-mappings.ts

@@ -184,6 +184,8 @@ const QUALITY_MAP: Record<string, QualityMapping> = {
   "seedance-2":          { field: "resolution", values: { low: "720p", mid: "1080p", high: "1080p" } },
   "seedance-2-fast":     { field: "resolution", values: { low: "480p", mid: "720p", high: "720p" } },
   "seedance-2-mini":     { field: "resolution", values: { low: "480p", mid: "720p", high: "720p" } },
+  // Seedance 2.5 tops out at 720p on KIE (1080p/4k probe-rejected 2026-08-08).
+  "seedance-2-5":        { field: "resolution", values: { low: "480p", mid: "720p", high: "720p" } },
   "wan-2.7-i2v":         { field: "resolution", values: { low: "720p", mid: "1080p", high: "1080p" } },
   "wan-2.7-t2v":         { field: "resolution", values: { low: "720p", mid: "1080p", high: "1080p" } },
   "happyhorse":          { field: "resolution", values: { low: "720p", mid: "1080p", high: "1080p" } },

package/src/node-mappable-fields.ts

@@ -31,7 +31,7 @@ export const NODE_MAPPABLE_FIELDS: Readonly<Record<string, readonly string[]>> =
   "suno-cover":          ["prompt", "lyrics", "style", "title", "negativeStyle"],
   "suno-extend":         ["prompt", "style", "title"],
   "suno-lyrics":         ["prompt"],
-  "suno-replace-section":["prompt", "tags", "title"],
+  "suno-replace-section":["prompt", "tags", "title", "fullLyrics", "negativeTags"],
   "suno-style-boost":    ["content"],
   "suno-upload-extend":  ["prompt", "style", "title"],
   "suno-mashup":         ["style", "title", "negativeStyle"],

package/src/pipeline-types.ts

@@ -65,6 +65,7 @@ export const PIPELINE_PINNABLE_VIDEO_MODELS = [
   "seedance-2",
   "seedance-2-fast",
   "seedance-2-mini",
+  "seedance-2-5",
   "veo3",
   "veo3.1",
   "veo3_lite",

package/src/provider-directive-defaults.ts

@@ -24,6 +24,10 @@ export const PROVIDER_DIRECTIVE_DEFAULTS = {
   "hailuo-2.3-pro": {} as Record<string, never>,
   "hailuo-standard": {} as Record<string, never>,
   minimax: {} as Record<string, never>,
+  // MiniMax Hailuo 3 — multimodal like seedance-2 but no verified directive
+  // semantics yet; empty until probed (NOTE: never match `minimax-h3` with a
+  // startsWith("seedance") / startsWith("minimax") prefix check — exact keys only).
+  "minimax-h3": {} as Record<string, never>,
   "bytedance-lite": {} as Record<string, never>,
 } as const