@nodaro/shared 1.4.2

package/src/__tests__/video-audio-capability.test.ts

@@ -0,0 +1,204 @@
+import { describe, it, expect } from "vitest"
+import {
+  VIDEO_AUDIO_CAPABILITY,
+  getVideoAudioCapability,
+  videoModelSupportsAudio,
+  videoModelCanSpeakDialogue,
+  applyVideoAudioToggle,
+  AUDIO_ADDON_PROVIDERS,
+  VEO_PROVIDERS,
+  SEEDANCE_2_PROVIDERS,
+  isSeedance2Provider,
+  VIDEO_REF_LIMITS_BY_PROVIDER,
+  SEEDANCE_2_REF_LIMITS,
+} from "../model-constants.js"
+
+describe("getVideoAudioCapability", () => {
+  it("returns native_speech (always on) for the VEO family", () => {
+    for (const m of ["veo3", "veo3.1", "veo3_lite"]) {
+      const cap = getVideoAudioCapability(m)
+      expect(cap.mode, m).toBe("native_speech")
+      expect(cap.alwaysOn, m).toBe(true)
+    }
+  })
+
+  it("returns ambient (sound toggle, cost-affecting) for Kling", () => {
+    for (const m of ["kling", "kling-3.0"]) {
+      const cap = getVideoAudioCapability(m)
+      expect(cap.mode, m).toBe("ambient")
+      expect(cap.field, m).toBe("sound")
+      expect(cap.affectsCost, m).toBe(true)
+    }
+  })
+
+  it("returns audio_driven for Seedance 2.0", () => {
+    for (const m of ["seedance-2", "seedance-2-fast"]) {
+      const cap = getVideoAudioCapability(m)
+      expect(cap.mode, m).toBe("audio_driven")
+      expect(cap.field, m).toBe("generateAudio")
+    }
+  })
+
+  it("returns ambient (audio but not dialogue) for Seedance 1.x", () => {
+    const cap = getVideoAudioCapability("seedance")
+    expect(cap.mode).toBe("ambient")
+    expect(cap.field).toBe("generateAudio")
+  })
+
+  it("defaults to none for silent / unknown / undefined models", () => {
+    for (const m of [
+      "minimax",
+      "hailuo-2.3",
+      "wan-i2v",
+      "grok-i2v",
+      "gemini-omni-video",
+      "runway",
+      "pika",
+      "totally-unknown-model",
+      undefined,
+    ]) {
+      expect(getVideoAudioCapability(m).mode, String(m)).toBe("none")
+    }
+  })
+})
+
+describe("videoModelSupportsAudio", () => {
+  it("is true for any model with an audio mode, false for silent", () => {
+    expect(videoModelSupportsAudio("veo3")).toBe(true)
+    expect(videoModelSupportsAudio("kling-3.0")).toBe(true)
+    expect(videoModelSupportsAudio("seedance-2")).toBe(true)
+    expect(videoModelSupportsAudio("seedance")).toBe(true)
+    expect(videoModelSupportsAudio("minimax")).toBe(false)
+    expect(videoModelSupportsAudio(undefined)).toBe(false)
+  })
+})
+
+describe("videoModelCanSpeakDialogue", () => {
+  it("is true only for native_speech + audio_driven models", () => {
+    expect(videoModelCanSpeakDialogue("veo3")).toBe(true)
+    expect(videoModelCanSpeakDialogue("veo3_lite")).toBe(true)
+    expect(videoModelCanSpeakDialogue("seedance-2")).toBe(true)
+    expect(videoModelCanSpeakDialogue("seedance-2-fast")).toBe(true)
+    expect(videoModelCanSpeakDialogue("seedance-2-mini")).toBe(true)
+    // ambient-only models are NOT dialogue-capable — their audio is SFX/ambient
+    expect(videoModelCanSpeakDialogue("kling")).toBe(false)
+    expect(videoModelCanSpeakDialogue("kling-3.0")).toBe(false)
+    expect(videoModelCanSpeakDialogue("seedance")).toBe(false)
+    expect(videoModelCanSpeakDialogue("minimax")).toBe(false)
+    expect(videoModelCanSpeakDialogue(undefined)).toBe(false)
+  })
+})
+
+describe("seedance-2-mini is a full Seedance 2 family member", () => {
+  it("is in the family set — drives the Frames/References mode toggle", () => {
+    expect(SEEDANCE_2_PROVIDERS.has("seedance-2-mini")).toBe(true)
+    expect(isSeedance2Provider("seedance-2-mini")).toBe(true)
+  })
+  it("carries the full multimodal reference caps (9 images / 3 videos / 3 audio)", () => {
+    expect(VIDEO_REF_LIMITS_BY_PROVIDER["seedance-2-mini"]).toEqual(SEEDANCE_2_REF_LIMITS)
+    expect(VIDEO_REF_LIMITS_BY_PROVIDER["seedance-2-mini"]).toEqual({ images: 9, videos: 3, audio: 3 })
+  })
+})
+
+describe("VIDEO_AUDIO_CAPABILITY internal consistency", () => {
+  it("every Kling AUDIO_ADDON provider is ambient + affectsCost", () => {
+    for (const m of AUDIO_ADDON_PROVIDERS) {
+      const cap = getVideoAudioCapability(m)
+      expect(cap.mode, m).toBe("ambient")
+      expect(cap.affectsCost, m).toBe(true)
+    }
+  })
+
+  it("every VEO provider is native_speech", () => {
+    for (const m of VEO_PROVIDERS) {
+      expect(getVideoAudioCapability(m).mode, m).toBe("native_speech")
+    }
+  })
+
+  it("every Seedance-2 provider is audio_driven", () => {
+    for (const m of SEEDANCE_2_PROVIDERS) {
+      expect(getVideoAudioCapability(m).mode, m).toBe("audio_driven")
+    }
+  })
+
+  it("affectsCost is set only for AUDIO_ADDON providers", () => {
+    for (const [model, cap] of Object.entries(VIDEO_AUDIO_CAPABILITY)) {
+      if (cap.affectsCost) expect(AUDIO_ADDON_PROVIDERS.has(model), model).toBe(true)
+    }
+  })
+
+  it("a user-controllable mode declares which field carries the toggle", () => {
+    for (const [model, cap] of Object.entries(VIDEO_AUDIO_CAPABILITY)) {
+      // alwaysOn models (VEO) have no toggle; everything else with audio must
+      // name the provider option field so the UI + worker wire the right one.
+      if (cap.mode !== "none" && !cap.alwaysOn) {
+        expect(cap.field, model).toBeDefined()
+      }
+    }
+  })
+})
+
+describe("applyVideoAudioToggle — neutral audio intent → per-model KIE field", () => {
+  it("maps the neutral toggle onto Kling's `sound` field", () => {
+    const input: Record<string, unknown> = {}
+    applyVideoAudioToggle(input, "kling", { sound: true })
+    expect(input.sound).toBe(true)
+    expect(input.generate_audio).toBeUndefined()
+  })
+
+  it("maps the neutral toggle onto Seedance's `generate_audio` field (the Studio bug)", () => {
+    // Studio sends ONLY `sound`, but Seedance's lever is `generate_audio`.
+    // Pre-fix the toggle was silently dropped on Seedance; it must now reach
+    // generate_audio in BOTH directions.
+    const on: Record<string, unknown> = {}
+    applyVideoAudioToggle(on, "seedance-2", { sound: true })
+    expect(on.generate_audio).toBe(true)
+    expect(on.sound).toBeUndefined()
+
+    const off: Record<string, unknown> = {}
+    applyVideoAudioToggle(off, "seedance-2", { sound: false })
+    expect(off.generate_audio).toBe(false)
+
+    const v1: Record<string, unknown> = {}
+    applyVideoAudioToggle(v1, "seedance", { sound: true })
+    expect(v1.generate_audio).toBe(true)
+  })
+
+  it("accepts `generateAudio` as a legacy alias on FREE models (Seedance)", () => {
+    const input: Record<string, unknown> = {}
+    applyVideoAudioToggle(input, "seedance", { generateAudio: true })
+    expect(input.generate_audio).toBe(true)
+  })
+
+  it("IGNORES the `generateAudio` alias on cost-affecting Kling — only `sound` toggles it", () => {
+    // Kling's audio is a credit surcharge keyed off `sound`. If the model honoured
+    // `generateAudio` too, a generateAudio-driven enable would generate (cost-affecting)
+    // audio the `sound`-keyed surcharge never billed. So the alias is gated off here.
+    const aliasOnly: Record<string, unknown> = {}
+    applyVideoAudioToggle(aliasOnly, "kling", { generateAudio: true })
+    expect(aliasOnly).toEqual({}) // no enable from the alias alone
+
+    const canonical: Record<string, unknown> = {}
+    applyVideoAudioToggle(canonical, "kling", { sound: true, generateAudio: false })
+    expect(canonical.sound).toBe(true) // the canonical lever still works (and wins)
+  })
+
+  it("is a no-op for always-on VEO — there is no user toggle to honour", () => {
+    const input: Record<string, unknown> = {}
+    applyVideoAudioToggle(input, "veo3", { sound: false })
+    expect(input).toEqual({})
+  })
+
+  it("is a no-op for silent / unknown models (not in the capability table)", () => {
+    const input: Record<string, unknown> = {}
+    applyVideoAudioToggle(input, "minimax", { sound: true })
+    applyVideoAudioToggle(input, undefined, { sound: true })
+    expect(input).toEqual({})
+  })
+
+  it("leaves the model's own default untouched when no intent is expressed", () => {
+    const input: Record<string, unknown> = { generate_audio: true }
+    applyVideoAudioToggle(input, "seedance-2", {})
+    expect(input.generate_audio).toBe(true)
+  })
+})

package/src/__tests__/video-gen-providers.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, it } from "vitest"
+import {
+  IMAGE_TO_VIDEO_PROVIDERS,
+  TEXT_TO_VIDEO_PROVIDERS,
+  VIDEO_GEN_PROVIDERS,
+  type VideoGenProvider,
+} from "../model-constants.js"
+
+describe("VIDEO_GEN_PROVIDERS", () => {
+  it("includes every IMAGE_TO_VIDEO_PROVIDERS entry", () => {
+    for (const p of IMAGE_TO_VIDEO_PROVIDERS) {
+      expect(VIDEO_GEN_PROVIDERS).toContain(p)
+    }
+  })
+  it("includes every TEXT_TO_VIDEO_PROVIDERS entry", () => {
+    for (const p of TEXT_TO_VIDEO_PROVIDERS) {
+      expect(VIDEO_GEN_PROVIDERS).toContain(p)
+    }
+  })
+  it("has no duplicates", () => {
+    const set = new Set(VIDEO_GEN_PROVIDERS)
+    expect(set.size).toBe(VIDEO_GEN_PROVIDERS.length)
+  })
+  it("VideoGenProvider type narrows correctly", () => {
+    const p: VideoGenProvider = "kling"
+    expect(VIDEO_GEN_PROVIDERS).toContain(p)
+  })
+})

package/src/__tests__/video-mode-aliases.test.ts

@@ -0,0 +1,150 @@
+import { describe, expect, it } from "vitest"
+import {
+  IMAGE_TO_VIDEO_PROVIDERS,
+  TEXT_TO_VIDEO_PROVIDERS,
+  VIDEO_GEN_PROVIDERS,
+  VIDEO_MODE_ALIASES,
+  VIDEO_GEN_COLLAPSED_T2V_IDS,
+  VIDEO_PROVIDERS_REQUIRING_IMAGE,
+  resolveVideoProviderForMode,
+} from "../model-constants.js"
+
+const I2V = "image-to-video"
+const T2V = "text-to-video"
+
+describe("resolveVideoProviderForMode", () => {
+  it("maps the i2v id to itself in i2v mode and to the t2v id in t2v mode (grok)", () => {
+    expect(resolveVideoProviderForMode("grok-i2v", I2V)).toBe("grok-i2v")
+    expect(resolveVideoProviderForMode("grok-i2v", T2V)).toBe("grok")
+  })
+
+  it("maps the t2v id to the i2v id in i2v mode (fixes the t2v-id-plus-image footgun)", () => {
+    // Picking the t2v 'grok' and connecting an image used to send 'grok' to the
+    // i2v path where KIE_VIDEO_MODELS['grok'] is undefined → crash. Now it
+    // resolves to the real i2v id.
+    expect(resolveVideoProviderForMode("grok", I2V)).toBe("grok-i2v")
+    expect(resolveVideoProviderForMode("grok", T2V)).toBe("grok")
+  })
+
+  it("maps Wan 2.6 ids by mode", () => {
+    expect(resolveVideoProviderForMode("wan-i2v", I2V)).toBe("wan-i2v")
+    expect(resolveVideoProviderForMode("wan-i2v", T2V)).toBe("wan")
+    expect(resolveVideoProviderForMode("wan", I2V)).toBe("wan-i2v")
+    expect(resolveVideoProviderForMode("wan", T2V)).toBe("wan")
+  })
+
+  it("maps Wan 2.7 ids by mode", () => {
+    expect(resolveVideoProviderForMode("wan-2.7-i2v", I2V)).toBe("wan-2.7-i2v")
+    expect(resolveVideoProviderForMode("wan-2.7-i2v", T2V)).toBe("wan-2.7-t2v")
+    expect(resolveVideoProviderForMode("wan-2.7-t2v", I2V)).toBe("wan-2.7-i2v")
+    expect(resolveVideoProviderForMode("wan-2.7-t2v", T2V)).toBe("wan-2.7-t2v")
+  })
+
+  it("maps HappyHorse ids by mode", () => {
+    expect(resolveVideoProviderForMode("happyhorse-i2v", I2V)).toBe("happyhorse-i2v")
+    expect(resolveVideoProviderForMode("happyhorse-i2v", T2V)).toBe("happyhorse")
+    expect(resolveVideoProviderForMode("happyhorse", I2V)).toBe("happyhorse-i2v")
+    expect(resolveVideoProviderForMode("happyhorse", T2V)).toBe("happyhorse")
+  })
+
+  it("passes non-aliased providers through unchanged in both modes", () => {
+    for (const p of ["kling", "seedance", "veo3", "minimax", "ltx-2.3-pro"]) {
+      expect(resolveVideoProviderForMode(p, I2V)).toBe(p)
+      expect(resolveVideoProviderForMode(p, T2V)).toBe(p)
+    }
+  })
+
+  it("passes single-id i2v-only models (grok-imagine-video-1.5) through unchanged", () => {
+    // It is its own id in both arrays — never aliased, so no remap.
+    expect(resolveVideoProviderForMode("grok-imagine-video-1.5", I2V)).toBe("grok-imagine-video-1.5")
+    expect(resolveVideoProviderForMode("grok-imagine-video-1.5", T2V)).toBe("grok-imagine-video-1.5")
+  })
+})
+
+describe("VIDEO_MODE_ALIASES registry honesty", () => {
+  it("every group's i2v id is a real image-to-video provider", () => {
+    for (const g of VIDEO_MODE_ALIASES) {
+      expect(IMAGE_TO_VIDEO_PROVIDERS as readonly string[]).toContain(g.i2v)
+    }
+  })
+
+  it("every group's t2v id is a real text-to-video provider", () => {
+    for (const g of VIDEO_MODE_ALIASES) {
+      expect(TEXT_TO_VIDEO_PROVIDERS as readonly string[]).toContain(g.t2v)
+    }
+  })
+
+  it("every group's base id is one of its own mode ids", () => {
+    for (const g of VIDEO_MODE_ALIASES) {
+      expect([g.i2v, g.t2v]).toContain(g.base)
+    }
+  })
+})
+
+describe("VIDEO_GEN_COLLAPSED_T2V_IDS (picker collapse set)", () => {
+  it("contains exactly the t2v twins whose i2v sibling is the picker base", () => {
+    expect(VIDEO_GEN_COLLAPSED_T2V_IDS).toEqual(new Set(["grok", "wan", "wan-2.7-t2v", "happyhorse"]))
+  })
+
+  it("every collapsed id is a t2v provider that is NOT also an i2v provider (safe to hide)", () => {
+    for (const id of VIDEO_GEN_COLLAPSED_T2V_IDS) {
+      expect(TEXT_TO_VIDEO_PROVIDERS as readonly string[]).toContain(id)
+      expect(IMAGE_TO_VIDEO_PROVIDERS as readonly string[]).not.toContain(id)
+    }
+  })
+})
+
+// ─── Unified-node dispatch totality ─────────────────────────────────────────
+// The unified Generate Video node can route ANY of its providers down EITHER
+// mode path: t2v when no image is wired, i2v when one is. After the alias
+// remap, the resolved id must therefore pass the target route's Zod enum in
+// BOTH directions. A provider in only one list (and not aliased) reaches the
+// other route as a raw Zod enum 400 — exactly the kling-3-omni /
+// "received 'kling-3-omni'" production error. i2v-only providers satisfy the
+// t2v direction by being listed in TEXT_TO_VIDEO_PROVIDERS and gated by
+// VIDEO_PROVIDERS_REQUIRING_IMAGE (clean "image required" 400 at the route).
+describe("unified generate-video dispatch totality", () => {
+  it("every VIDEO_GEN_PROVIDERS member resolves to a valid t2v route provider", () => {
+    const t2v = new Set<string>(TEXT_TO_VIDEO_PROVIDERS)
+    const broken = VIDEO_GEN_PROVIDERS.filter(
+      (p) => !t2v.has(resolveVideoProviderForMode(p, T2V)),
+    )
+    expect(
+      broken,
+      `These unified-picker providers crash /v1/text-to-video with a Zod enum error when run without an image — add them to TEXT_TO_VIDEO_PROVIDERS (i2v-only models get the friendly 400 via VIDEO_PROVIDERS_REQUIRING_IMAGE) or alias them to a t2v twin: ${broken.join(", ")}`,
+    ).toEqual([])
+  })
+
+  it("every VIDEO_GEN_PROVIDERS member resolves to a valid i2v route provider", () => {
+    const i2v = new Set<string>(IMAGE_TO_VIDEO_PROVIDERS)
+    const broken = VIDEO_GEN_PROVIDERS.filter(
+      (p) => !i2v.has(resolveVideoProviderForMode(p, I2V)),
+    )
+    expect(
+      broken,
+      `These unified-picker providers fail the /v1/generate-video path when an image IS wired — add them to IMAGE_TO_VIDEO_PROVIDERS or alias them to an i2v twin: ${broken.join(", ")}`,
+    ).toEqual([])
+  })
+})
+
+describe("VIDEO_PROVIDERS_REQUIRING_IMAGE (derived from MODEL_CATALOG modes)", () => {
+  it("contains exactly the unaliased i2v-only unified-picker providers", () => {
+    expect(new Set(VIDEO_PROVIDERS_REQUIRING_IMAGE)).toEqual(
+      new Set([
+        "grok-imagine-video-1.5",
+        "kling-3-omni",
+        "kling-master",
+        "hailuo-2.3",
+        "hailuo-2.3-pro",
+        "bytedance-pro-fast",
+        "happyhorse-ref2v",
+      ]),
+    )
+  })
+
+  it("never contains a provider with a real t2v path (would wrongly block it)", () => {
+    for (const p of VIDEO_PROVIDERS_REQUIRING_IMAGE) {
+      expect(resolveVideoProviderForMode(p, T2V), `${p} is aliased to a t2v twin — it must not be image-gated`).toBe(p)
+    }
+  })
+})

package/src/__tests__/video-ref-limits.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, it } from "vitest"
+import {
+  SEEDANCE_2_REF_LIMITS,
+  VIDEO_REF_LIMITS_BY_PROVIDER,
+} from "../model-constants.js"
+import { MODEL_CATALOG } from "../model-catalog.js"
+
+describe("VIDEO_REF_LIMITS_BY_PROVIDER", () => {
+  it("seedance-2 providers get the SEEDANCE_2_REF_LIMITS shape", () => {
+    expect(VIDEO_REF_LIMITS_BY_PROVIDER["seedance-2"]).toEqual({
+      images: SEEDANCE_2_REF_LIMITS.images,
+      videos: SEEDANCE_2_REF_LIMITS.videos,
+      audio: SEEDANCE_2_REF_LIMITS.audio,
+    })
+    expect(VIDEO_REF_LIMITS_BY_PROVIDER["seedance-2-fast"]).toEqual({
+      images: SEEDANCE_2_REF_LIMITS.images,
+      videos: SEEDANCE_2_REF_LIMITS.videos,
+      audio: SEEDANCE_2_REF_LIMITS.audio,
+    })
+  })
+  it("non-seedance providers either have just an images cap or are absent", () => {
+    expect(VIDEO_REF_LIMITS_BY_PROVIDER["grok-i2v"]?.images).toBeGreaterThanOrEqual(1)
+    expect(VIDEO_REF_LIMITS_BY_PROVIDER["kling-turbo"]).toBeUndefined()
+    // Not verified reference-forwarders (2026-06-28 audit) → deliberately absent.
+    expect(VIDEO_REF_LIMITS_BY_PROVIDER["wan-i2v"]).toBeUndefined()
+    expect(VIDEO_REF_LIMITS_BY_PROVIDER["grok-imagine-video-1.5"]).toBeUndefined()
+  })
+})
+
+describe("VIDEO_REF_LIMITS_BY_PROVIDER ⇄ MODEL_CATALOG drift guard", () => {
+  // The catalog (kind:"video" + features:["reference-image"]) is the SINGLE
+  // authority on WHICH video models accept image references;
+  // VIDEO_REF_LIMITS_BY_PROVIDER holds the per-provider NUMERIC caps. These two
+  // MUST stay in 1:1 correspondence — a ref-capable video model with no cap entry
+  // (or a cap entry with no catalog flag) is exactly the drift that silently broke
+  // `connectedReferences` coverage (6 ref-capable models had no cap; 6 capped
+  // models weren't flagged). This invariant fails CI on any future divergence.
+  const catalogRefVideoIds = Object.values(MODEL_CATALOG)
+    .filter((m) => m.kind === "video" && m.features?.includes("reference-image"))
+    .map((m) => m.id)
+    .sort()
+  const mapIds = Object.keys(VIDEO_REF_LIMITS_BY_PROVIDER).sort()
+
+  it("every reference-capable video model in the catalog has a numeric cap entry", () => {
+    const missing = catalogRefVideoIds.filter((id) => !(id in VIDEO_REF_LIMITS_BY_PROVIDER))
+    expect(missing).toEqual([])
+  })
+
+  it("every numeric cap entry corresponds to a reference-capable video model in the catalog", () => {
+    const orphan = mapIds.filter((id) => !catalogRefVideoIds.includes(id))
+    expect(orphan).toEqual([])
+  })
+
+  it("the two sets are exactly equal (no drift in either direction)", () => {
+    expect(mapIds).toEqual(catalogRefVideoIds)
+  })
+})
+
+describe("VIDEO_REF_LIMITS_BY_PROVIDER caps for the newly-covered models", () => {
+  it("VEO family carries images:3 (the REFERENCE_2_VIDEO slice cap in kie/video.ts)", () => {
+    expect(VIDEO_REF_LIMITS_BY_PROVIDER["veo3"]).toEqual({ images: 3 })
+    expect(VIDEO_REF_LIMITS_BY_PROVIDER["veo3.1"]).toEqual({ images: 3 })
+    expect(VIDEO_REF_LIMITS_BY_PROVIDER["veo3_lite"]).toEqual({ images: 3 })
+  })
+  it("kling-3-omni and grok-i2v carry images:7", () => {
+    expect(VIDEO_REF_LIMITS_BY_PROVIDER["kling-3-omni"]).toEqual({ images: 7 })
+    expect(VIDEO_REF_LIMITS_BY_PROVIDER["grok-i2v"]).toEqual({ images: 7 })
+  })
+  it("happyhorse-ref2v carries images:9", () => {
+    expect(VIDEO_REF_LIMITS_BY_PROVIDER["happyhorse-ref2v"]).toEqual({ images: 9 })
+  })
+})