@nodaro/shared 2.17.0 → 2.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nodaro/shared",
-  "version": "2.17.0",
+  "version": "2.19.0",
   "description": "Shared types, model catalog, wire contracts, and structural vocabularies for the Nodaro platform and SDK.",
   "type": "module",
   "license": "Apache-2.0",

package/src/__tests__/apply-video-negative-prompt.test.ts

@@ -1,5 +1,37 @@
 import { describe, it, expect } from "vitest"
-import { applyVideoNegativePrompt, NATIVE_NEGATIVE_VIDEO_PROVIDERS } from "../model-constants.js"
+import {
+  applyVideoNegativePrompt,
+  videoNegativeSuffix,
+  NATIVE_NEGATIVE_VIDEO_PROVIDERS,
+} from "../model-constants.js"
+
+/**
+ * A composed prompt that ends with the `[style]` section — what
+ * `@nodaro/prompts` emits for any run that picks a look dimension. The section
+ * has no terminator, so a `"\n"`-joined `Avoid:` reads as one more look clause
+ * under its header.
+ */
+const SECTIONED = "a knight rides\n\n[style]:\nanime style\nwide shot"
+
+describe("videoNegativeSuffix", () => {
+  it("joins on one newline for an ordinary prompt", () => {
+    expect(videoNegativeSuffix("blurry", "a knight rides")).toBe("\nAvoid: blurry")
+  })
+
+  it("closes an open `[style]` section with a blank line", () => {
+    expect(videoNegativeSuffix("blurry", SECTIONED)).toBe("\n\nAvoid: blurry")
+  })
+
+  it("joins on one newline once something else closed the section", () => {
+    expect(videoNegativeSuffix("blurry", `${SECTIONED}\n\nthe person from @image_1`))
+      .toBe("\nAvoid: blurry")
+  })
+
+  it("is the WIDEST form with no base — what a caller reserving room must budget", () => {
+    // `effectiveVideoPromptCeiling` reserves before the prompt exists.
+    expect(videoNegativeSuffix("blurry")).toBe("\n\nAvoid: blurry")
+  })
+})
 
 describe("applyVideoNegativePrompt", () => {
   it("returns prompt unchanged + nativeNegativePrompt when provider is native", () => {
@@ -14,6 +46,11 @@ describe("applyVideoNegativePrompt", () => {
     expect(result.nativeNegativePrompt).toBeUndefined()
   })
 
+  it("separates 'Avoid: …' from an unterminated `[style]` section", () => {
+    const result = applyVideoNegativePrompt(SECTIONED, "blurry", "wan-animate-move")
+    expect(result.prompt).toBe(`${SECTIONED}\n\nAvoid: blurry`)
+  })
+
   it("returns 'Avoid: …' alone when prompt is empty and provider is non-native", () => {
     const result = applyVideoNegativePrompt("", "blurry", "veo3")
     expect(result.prompt).toBe("Avoid: blurry")

package/src/__tests__/credit-identifiers.test.ts

@@ -823,3 +823,50 @@ describe("gemini-omni-video", () => {
     expect(id({ duration: 6, resolution: "720p", nodeType: "text-to-video" })).toBe("gemini-omni-video:6")
   })
 })
+
+// ---------------------------------------------------------------------------
+// gemini-omni-flash credit identifier — the family branch reaches the sibling
+// ---------------------------------------------------------------------------
+// The Omni branch used to compare against the literal "gemini-omni-video" and
+// hardcode that prefix in every returned string. It now asks
+// isGeminiOmniProvider() and TEMPLATES the prefix, so this block is the proof
+// that the refactor actually reaches the second SKU (the block above proves it
+// stayed behaviour-neutral for the first). A flash run that fell through to the
+// DURATION_PRICED gate would return the BARE id and reserve 270 credits for a
+// 4K 10s render.
+describe("gemini-omni-flash", () => {
+  const id = (opts: { duration?: number | string; resolution?: string; hasVideoRef?: boolean; nodeType?: "image-to-video" | "text-to-video" }) =>
+    buildVideoCreditModelIdentifier("gemini-omni-flash", opts.duration, undefined, opts.nodeType ?? "image-to-video", undefined, opts.resolution, opts.hasVideoRef)
+
+  it("prices 720p/1080p by duration tier", () => {
+    expect(id({ duration: 4, resolution: "720p" })).toBe("gemini-omni-flash:4")
+    expect(id({ duration: 6, resolution: "1080p" })).toBe("gemini-omni-flash:6")
+    expect(id({ duration: 8, resolution: "720p" })).toBe("gemini-omni-flash:8")
+    expect(id({ duration: 10, resolution: "1080p" })).toBe("gemini-omni-flash:10")
+  })
+  it("prices 4k by duration tier", () => {
+    expect(id({ duration: 4, resolution: "4k" })).toBe("gemini-omni-flash:4k:4")
+    expect(id({ duration: 10, resolution: "4k" })).toBe("gemini-omni-flash:4k:10")
+  })
+  it("prices V2V flat, ignoring duration", () => {
+    expect(id({ duration: 8, resolution: "1080p", hasVideoRef: true })).toBe("gemini-omni-flash:vref")
+    expect(id({ duration: 8, resolution: "4k", hasVideoRef: true })).toBe("gemini-omni-flash:4k:vref")
+  })
+  it("snaps off-tier durations to nearest allowed tier (never :5)", () => {
+    expect(id({ duration: 5, resolution: "720p" })).toBe("gemini-omni-flash:4")
+    expect(id({ duration: 12, resolution: "720p" })).toBe("gemini-omni-flash:10")
+  })
+  it("defaults to tier 8 when duration is undefined", () => {
+    expect(id({ resolution: "720p" })).toBe("gemini-omni-flash:8")
+  })
+  it("works on the text-to-video path too", () => {
+    expect(id({ duration: 6, resolution: "720p", nodeType: "text-to-video" })).toBe("gemini-omni-flash:6")
+  })
+  it("never falls through to the bare id (the pre-refactor failure mode)", () => {
+    for (const d of [undefined, 4, 6, 8, 10, 5, 12]) {
+      for (const r of [undefined, "720p", "1080p", "4k"]) {
+        expect(id({ duration: d, resolution: r })).not.toBe("gemini-omni-flash")
+      }
+    }
+  })
+})

package/src/__tests__/gvp-supported-providers.test.ts

@@ -51,7 +51,10 @@ describe("GVP_SUPPORTED_PROVIDERS", () => {
       "veo3.1",
       "veo3_lite",
       "gemini-omni-video",
+      "gemini-omni-flash",
       "grok-i2v",
+      "wan-3",
+      "wan-3-prime",
       "happyhorse-ref2v",
     ])
   })
@@ -154,8 +157,20 @@ describe("GVP_EXTEND_PROVIDERS", () => {
     expect(supportsExtendRender("gemini-omni-video")).toBe(false)
   })
 
+  it("excludes wan-3 — reference videos are accepted but the extend chain is unwired", () => {
+    // Wan 3.0 takes reference_video_urls, but (a) there is no wan-3 r2v
+    // forwarding path yet and (b) KIE caps input-video seconds + output
+    // duration at 30, which the segment bounds cannot express. So the catalog
+    // deliberately withholds the `video-reference` feature: blessed for
+    // keyframes, not for extend. Same precedent as gemini-omni-video.
+    for (const p of ["wan-3", "wan-3-prime"]) {
+      expect(isGvpSupportedProvider(p)).toBe(true)
+      expect(supportsExtendRender(p)).toBe(false)
+    }
+  })
+
   it("keyframes-only SKUs reject extend", () => {
-    for (const p of ["veo3", "veo3.1", "veo3_lite", "gemini-omni-video", "grok-i2v", "happyhorse-ref2v"]) {
+    for (const p of ["veo3", "veo3.1", "veo3_lite", "gemini-omni-video", "gemini-omni-flash", "grok-i2v", "happyhorse-ref2v", "wan-3", "wan-3-prime"]) {
       expect(isGvpSupportedProvider(p)).toBe(true)
       expect(supportsExtendRender(p)).toBe(false)
     }
@@ -174,6 +189,8 @@ describe("GVP_END_FRAME_PROVIDERS", () => {
       "veo3",
       "veo3.1",
       "veo3_lite",
+      "wan-3",
+      "wan-3-prime",
     ])
   })
 
@@ -186,6 +203,10 @@ describe("GVP_END_FRAME_PROVIDERS", () => {
 
   it("excludes SKUs with no closing-frame support", () => {
     expect(supportsEndAnchor("gemini-omni-video")).toBe(false)
+    // Gemini Omni Flash mirrors its sibling exactly — the KIE schema exposes
+    // first/last frame but the path is unwired for BOTH Omni SKUs, so neither
+    // declares the catalog `end-frame` feature.
+    expect(supportsEndAnchor("gemini-omni-flash")).toBe(false)
     expect(supportsEndAnchor("grok-i2v")).toBe(false)
     expect(supportsEndAnchor("happyhorse-ref2v")).toBe(false)
     expect(supportsEndAnchor(undefined)).toBe(false)

package/src/__tests__/prompt-length-limits.test.ts

@@ -66,6 +66,10 @@ describe("per-model prompt length limits", () => {
     it("returns verified higher caps", () => {
       expect(getMaxVideoPromptChars("seedance-2")).toBe(20000)
       expect(getMaxVideoPromptChars("gemini-omni-video")).toBe(20000)
+      expect(getMaxVideoPromptChars("gemini-omni-flash")).toBe(20000)
+      // Wan 3.0 family — 20000 chars, truncated by the provider beyond that.
+      expect(getMaxVideoPromptChars("wan-3")).toBe(20000)
+      expect(getMaxVideoPromptChars("wan-3-prime")).toBe(20000)
       expect(getMaxVideoPromptChars("bytedance-pro")).toBe(10000)
     })
     it("falls back to VIDEO_PROMPT_MAX for UNVERIFIED + unknown providers", () => {

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

@@ -63,6 +63,21 @@ describe("getVideoAudioCapability", () => {
     expect(cap.field).toBe("generateAudio")
   })
 
+  it("returns ambient with the `audio` field for the Wan 3.0 family", () => {
+    // Wan 3.0's lever is literally `input.audio` — neither `sound` nor
+    // `generate_audio`. Classified "ambient", NOT audio_driven: the KIE schema
+    // documents no dialogue guarantee, and reference audio is a generic
+    // conditioning array rather than a verified lip-sync transport.
+    for (const m of ["wan-3", "wan-3-prime"]) {
+      const cap = getVideoAudioCapability(m)
+      expect(cap.mode, m).toBe("ambient")
+      expect(cap.field, m).toBe("audio")
+      expect(cap.defaultOn, m).toBe(true)
+      // Audio is priced into the uniform per-second rate — no `:audio` composite.
+      expect(cap.affectsCost, m).toBeUndefined()
+    }
+  })
+
   it("defaults to none for silent / unknown / undefined models", () => {
     for (const m of [
       "minimax",
@@ -70,6 +85,9 @@ describe("getVideoAudioCapability", () => {
       "wan-i2v",
       "grok-i2v",
       "gemini-omni-video",
+      // Gemini Omni Flash mirrors its sibling: deliberately unlisted, so both
+      // Omni SKUs report the same audio capability.
+      "gemini-omni-flash",
       "runway",
       "pika",
       "totally-unknown-model",
@@ -192,6 +210,31 @@ describe("applyVideoAudioToggle — neutral audio intent → per-model KIE field
     expect(v1.generate_audio).toBe(true)
   })
 
+  it("maps the neutral toggle onto Wan 3.0's `audio` field", () => {
+    // The dispatcher used to be a two-way if/else whose `else` wrote
+    // `input.sound` — a field the Wan 3.0 contract does not have, so the
+    // toggle would have been silently dropped.
+    const on: Record<string, unknown> = {}
+    applyVideoAudioToggle(on, "wan-3", { sound: true })
+    expect(on.audio).toBe(true)
+    expect(on.sound).toBeUndefined()
+    expect(on.generate_audio).toBeUndefined()
+
+    const off: Record<string, unknown> = {}
+    applyVideoAudioToggle(off, "wan-3-prime", { sound: false })
+    expect(off.audio).toBe(false)
+
+    // Not cost-affecting, so the legacy alias is honoured too.
+    const alias: Record<string, unknown> = {}
+    applyVideoAudioToggle(alias, "wan-3", { generateAudio: true })
+    expect(alias.audio).toBe(true)
+
+    // No intent → the model's own default (KIE `audio: true`) is left alone.
+    const neutral: Record<string, unknown> = {}
+    applyVideoAudioToggle(neutral, "wan-3", {})
+    expect(neutral).toEqual({})
+  })
+
   it("accepts `generateAudio` as a legacy alias on FREE models (Seedance)", () => {
     const input: Record<string, unknown> = {}
     applyVideoAudioToggle(input, "seedance", { generateAudio: true })

package/src/__tests__/video-mode-for-inputs.test.ts

@@ -43,7 +43,7 @@ describe("resolveVideoModeForInputs", () => {
     // (generate-video.md mode table). kling-3-omni is i2v-only and keeps its
     // documented orchestrator behavior (image_required on the t2v path) —
     // whether refs alone should satisfy it is a separate question from #861.
-    for (const id of ["seedance-2", "gemini-omni-video", "veo3.1", "kling-3-omni"]) {
+    for (const id of ["seedance-2", "gemini-omni-video", "gemini-omni-flash", "veo3.1", "kling-3-omni", "wan-3", "wan-3-prime"]) {
       expect(resolveVideoModeForInputs(id, { hasStartFrame: false, hasImageRefs: true })).toBe(T2V)
     }
   })

package/src/__tests__/wan-3-catalog.test.ts

@@ -0,0 +1,243 @@
+import { describe, it, expect } from "vitest"
+import { MODEL_CATALOG } from "../model-catalog.js"
+import {
+  IMAGE_TO_VIDEO_PROVIDERS,
+  TEXT_TO_VIDEO_PROVIDERS,
+  VIDEO_REF_LIMITS_BY_PROVIDER,
+  VIDEO_PROVIDERS_REQUIRING_IMAGE,
+  getVideoAudioCapability,
+  defaultVideoAspectRatio,
+  getMaxVideoPromptChars,
+  WAN_3_PROVIDERS,
+  isWan3Provider,
+  WAN_3_DEFAULT_RESOLUTION,
+  normalizeWan3Resolution,
+  isSeedance2Provider,
+  isMinimaxH3Provider,
+  SEEDANCE_2_PROVIDERS,
+  DURATION_PRICED_PROVIDERS,
+  VIDEO_DURATION_TIERS,
+  RESOLUTION_DURATION_PRICING,
+  PRICING_DEFAULT_RESOLUTION,
+  NATIVE_ADAPTIVE_ASPECT,
+  SEEDANCE_2_R2V_MAX_AUDIO_SEC_BY_PROVIDER,
+  GVP_SUPPORTED_PROVIDERS,
+  GVP_EXTEND_PROVIDERS,
+} from "../model-constants.js"
+import { buildVideoCreditModelIdentifier } from "../credit-identifiers.js"
+
+const WAN_3_IDS = ["wan-3", "wan-3-prime"] as const
+const DURATIONS_2_TO_30 = Array.from({ length: 29 }, (_, i) => i + 2)
+
+describe("wan-3 / wan-3-prime catalog", () => {
+  for (const id of WAN_3_IDS) {
+    describe(id, () => {
+      const entry = MODEL_CATALOG[id]
+
+      it("exists with both video modes under ONE id (no t2v twin, no alias)", () => {
+        expect(entry).toBeDefined()
+        expect(entry.kind).toBe("video")
+        expect([...entry.modes].sort()).toEqual(["i2v", "t2v"])
+        expect(entry.series).toBe("Wan")
+        expect(entry.family).toBe("Alibaba")
+      })
+
+      it("lists resolutions ASCENDING — the default is declared, not smuggled in at index 0", () => {
+        // Every video entry in the catalog is ascending, and three unrelated
+        // consumers read index 0 (the frontend fail-safe snap, payload-builder's
+        // resolution fill, the GVP display order). The 720p billing/render
+        // default lives in PRICING_DEFAULT_RESOLUTION instead.
+        expect(entry.resolutions).toEqual(["480p", "720p", "1080p"])
+        expect(PRICING_DEFAULT_RESOLUTION[id]).toBe("720p")
+      })
+
+      it("offers every integer second 2-30 (`-1` model-chosen duration is NOT exposed)", () => {
+        expect(entry.durations).toEqual(DURATIONS_2_TO_30)
+        expect(entry.durations).not.toContain(-1)
+      })
+
+      it("uses the Wan 3.0 six-ratio set: adaptive first, NO 21:9", () => {
+        expect(entry.aspectRatios).toEqual(["adaptive", "16:9", "4:3", "1:1", "3:4", "9:16"])
+        // Reusing VIDEO_RATIOS_SEEDANCE_2 would have offered 21:9, which the
+        // Wan 3.0 enum rejects at request time.
+        expect(entry.aspectRatios).not.toContain("21:9")
+      })
+
+      it("declares end-frame + audio + reference-image, and deliberately NOT video-reference", () => {
+        expect(entry.features).toEqual(expect.arrayContaining(["end-frame", "audio", "reference-image"]))
+        // `video-reference` would derive wan into GVP_EXTEND_PROVIDERS, but the
+        // r2v forwarding path is unwired and KIE caps input-video + output at
+        // 30s — a bound the segment splitter cannot express.
+        expect(entry.features).not.toContain("video-reference")
+      })
+    })
+  }
+})
+
+describe("wan-3 provider wiring", () => {
+  for (const id of WAN_3_IDS) {
+    it(`${id} is registered for BOTH t2v and i2v and is NOT image-required`, () => {
+      expect(IMAGE_TO_VIDEO_PROVIDERS).toContain(id)
+      expect(TEXT_TO_VIDEO_PROVIDERS).toContain(id)
+      expect(VIDEO_PROVIDERS_REQUIRING_IMAGE.has(id)).toBe(false)
+    })
+
+    it(`${id} carries the 10/5/5 multimodal reference caps`, () => {
+      expect(VIDEO_REF_LIMITS_BY_PROVIDER[id]).toEqual({ images: 10, videos: 5, audio: 5 })
+      expect(SEEDANCE_2_R2V_MAX_AUDIO_SEC_BY_PROVIDER[id]).toBe(15)
+    })
+
+    it(`${id} audio capability: ambient behind the model's own \`audio\` boolean, default on`, () => {
+      const cap = getVideoAudioCapability(id)
+      expect(cap.mode).toBe("ambient")
+      expect(cap.field).toBe("audio")
+      expect(cap.defaultOn).toBe(true)
+      expect(cap.affectsCost).toBeUndefined()
+    })
+
+    it(`${id} defaults to the adaptive aspect (the KIE default, first in its enum)`, () => {
+      expect(defaultVideoAspectRatio(id)).toBe("adaptive")
+      expect(NATIVE_ADAPTIVE_ASPECT[id]).toBe("adaptive")
+    })
+
+    it(`${id} prompt cap is the documented 20000 chars`, () => {
+      expect(getMaxVideoPromptChars(id)).toBe(20000)
+    })
+
+    it(`${id} prices per second: one duration tier per allowed second 2-30`, () => {
+      expect(DURATION_PRICED_PROVIDERS.has(id)).toBe(true)
+      const tiers = VIDEO_DURATION_TIERS[id]
+      expect(tiers.map((t) => t.maxSeconds)).toEqual(DURATIONS_2_TO_30)
+      expect(RESOLUTION_DURATION_PRICING[id]).toEqual(["480p", "720p", "1080p"])
+    })
+  }
+})
+
+describe("wan-3 family predicate — exact membership, never prefix-matched", () => {
+  it("matches exactly the two Wan 3.0 SKUs", () => {
+    expect([...WAN_3_PROVIDERS].sort()).toEqual(["wan-3", "wan-3-prime"])
+    expect(isWan3Provider("wan-3")).toBe(true)
+    expect(isWan3Provider("wan-3-prime")).toBe(true)
+  })
+
+  it("does NOT match any Wan 2.x id (the prefix trap)", () => {
+    for (const other of ["wan", "wan-i2v", "wan-turbo", "wan-flash", "wan-videoedit", "wan-2.7-i2v", "wan-2.7-t2v"]) {
+      expect(isWan3Provider(other), other).toBe(false)
+    }
+    expect(isWan3Provider(undefined)).toBe(false)
+    expect(isWan3Provider("")).toBe(false)
+  })
+
+  it("stays OUT of the Seedance 2 and MiniMax H3 family sets", () => {
+    for (const id of WAN_3_IDS) {
+      expect(isSeedance2Provider(id), id).toBe(false)
+      expect(SEEDANCE_2_PROVIDERS.has(id), id).toBe(false)
+      expect(isMinimaxH3Provider(id), id).toBe(false)
+    }
+  })
+
+  it("IS a blessed GVP SKU (derived) but NOT extend-eligible", () => {
+    for (const id of WAN_3_IDS) {
+      expect([...GVP_SUPPORTED_PROVIDERS], id).toContain(id)
+      expect([...GVP_EXTEND_PROVIDERS], id).not.toContain(id)
+    }
+  })
+})
+
+describe("normalizeWan3Resolution — the ONE producer of the uppercase wire form", () => {
+  it("uppercases a supported tier, case-insensitively", () => {
+    expect(normalizeWan3Resolution("480p")).toBe("480P")
+    expect(normalizeWan3Resolution("480P")).toBe("480P")
+    expect(normalizeWan3Resolution("720p")).toBe("720P")
+    expect(normalizeWan3Resolution("1080P")).toBe("1080P")
+    expect(normalizeWan3Resolution(" 1080p ")).toBe("1080P")
+  })
+
+  it("collapses undefined / garbage / an off-menu tier to the 720P platform default", () => {
+    expect(WAN_3_DEFAULT_RESOLUTION).toBe("720P")
+    // 720P, not KIE's own 1080P default: the bare credit identifier prices the
+    // 720p tier, so billing can never undercut the render.
+    expect(normalizeWan3Resolution(undefined)).toBe("720P")
+    expect(normalizeWan3Resolution("")).toBe("720P")
+    expect(normalizeWan3Resolution("4k")).toBe("720P")
+    expect(normalizeWan3Resolution("2K")).toBe("720P")
+  })
+})
+
+describe("wan-3 credit identifiers — totality over the whole (duration × resolution) space", () => {
+  const build = (provider: string, duration?: number, resolution?: string) =>
+    buildVideoCreditModelIdentifier(provider, duration, undefined, "image-to-video", undefined, resolution, undefined)
+
+  for (const id of WAN_3_IDS) {
+    it(`${id} emits exactly one composite per (duration, resolution) pair — 87 distinct ids`, () => {
+      const emitted = new Set<string>()
+      for (const d of DURATIONS_2_TO_30) {
+        for (const res of ["480p", "720p", "1080p"]) {
+          const identifier = build(id, d, res)
+          expect(identifier, `${id} ${d}s ${res}`).toBe(`${id}:${d}s:${res}`)
+          emitted.add(identifier)
+        }
+      }
+      expect(emitted.size).toBe(87)
+    })
+
+    it(`${id} prices an OMITTED resolution at the declared 720p default, not the cheapest tier`, () => {
+      // The tier list is ascending, so a bare resTiers[0] fallback would have
+      // reserved 480p against a 720p render — and commit_credits (refund-only)
+      // can never collect the shortfall.
+      expect(build(id, 5)).toBe(`${id}:5s:720p`)
+      expect(build(id, 8)).toBe(`${id}:8s:720p`)
+    })
+
+    it(`${id} collapses an UNSUPPORTED resolution to the same 720p default`, () => {
+      for (const bogus of ["4k", "2k", "360p", "768P", "not-a-resolution"]) {
+        expect(build(id, 5, bogus), bogus).toBe(`${id}:5s:720p`)
+      }
+    })
+
+    it(`${id} bills the tier it RENDERS for every spelling of the resolution`, () => {
+      // The render path is `normalizeWan3Resolution` (case-insensitive, trims),
+      // so the billing path must collapse through the SAME normalizer. KIE's own
+      // OpenAPI enum is UPPERCASE ("1080P"), which is the natural value for an
+      // integrator reading the provider docs and reaches both consumers raw:
+      // the route Zod is `z.string().optional()` and neither the credit builder
+      // nor the queue payload canonicalises it. A case-sensitive `includes`
+      // rendered 1080P while billing the 720p row — a 2x shortfall that
+      // commit_credits (refund-only) can never collect.
+      for (const spelling of ["1080P", "480P", "720P", " 720p ", "1080p", "480p", "720p", "4K", "garbage"]) {
+        const rendered = normalizeWan3Resolution(spelling).toLowerCase()
+        expect(build(id, 5, spelling), `${id} 5s "${spelling}"`).toBe(`${id}:5s:${rendered}`)
+        expect(build(id, 30, spelling), `${id} 30s "${spelling}"`).toBe(`${id}:30s:${rendered}`)
+      }
+    })
+
+    it(`${id} snaps an off-menu duration into a seeded tier rather than the bare id`, () => {
+      // Below the floor → the first tier; above the ceiling → the last one.
+      expect(build(id, 1, "720p")).toBe(`${id}:2s:720p`)
+      expect(build(id, 45, "720p")).toBe(`${id}:30s:720p`)
+      // An omitted duration renders the KIE default of 5s.
+      expect(build(id, undefined, "720p")).toBe(`${id}:5s:720p`)
+    })
+
+    it(`${id} never emits the bare id from the generate path`, () => {
+      for (const d of [undefined, ...DURATIONS_2_TO_30]) {
+        for (const res of [undefined, "480p", "720p", "1080p", "4k"]) {
+          expect(build(id, d, res)).not.toBe(id)
+        }
+      }
+    })
+  }
+
+  it("every catalog pricing row for the family is an id the builder can actually emit", () => {
+    for (const id of WAN_3_IDS) {
+      for (const row of MODEL_CATALOG[id].pricing ?? []) {
+        // The bare row is the reservation-time default; every other row is a
+        // duration×resolution composite the builder must be able to produce.
+        if (row.identifier === id) continue
+        const m = /^(.+):(\d+)s:(\d+p)$/.exec(row.identifier)
+        expect(m, row.identifier).not.toBeNull()
+        expect(build(m![1]!, Number(m![2]), m![3])).toBe(row.identifier)
+      }
+    }
+  })
+})

package/src/credit-identifiers.ts

@@ -21,7 +21,10 @@ import {
   T2I_TO_I2I_VARIANT,
   isVeoProvider,
   isMinimaxH3Provider,
+  isGeminiOmniProvider,
+  isWan3Provider,
   normalizeMinimaxH3Resolution,
+  normalizeWan3Resolution,
   getVideoAudioCapability,
 } from "./model-constants.js"
 import { isFlux2Model } from "./flux2-pricing.js"
@@ -137,9 +140,11 @@ const T2V_CREDIT_OVERRIDES: Record<string, string> = {
  * @param resolution - Output resolution (used by Seedance 2 for 480p/720p pricing)
  * @param hasVideoRef - Whether a reference video is connected (Seedance 2 uses a lower per-second rate when true)
  */
-/** Gemini Omni Video duration tiers (seconds). Mirrors `MODEL_CATALOG["gemini-omni-video"].durations`
- *  and `KIE_VIDEO_MODELS["gemini-omni-video"].allowedDurations`. Hoisted to module scope so the
- *  nearest-tier snap below doesn't reallocate on every (hot-path) call. */
+/** Gemini Omni duration tiers (seconds). Mirrors the `durations` of BOTH
+ *  `MODEL_CATALOG["gemini-omni-video"]` and `MODEL_CATALOG["gemini-omni-flash"]`
+ *  (and their `KIE_VIDEO_MODELS[*].allowedDurations`) — the family shares one
+ *  ladder. Hoisted to module scope so the nearest-tier snap below doesn't
+ *  reallocate on every (hot-path) call. */
 const GEMINI_OMNI_DURATIONS = [4, 6, 8, 10]
 
 /**
@@ -191,17 +196,21 @@ export function buildVideoCreditModelIdentifier(
     return effectiveProvider
   }
 
-  // Gemini Omni Video: priced by (resolution-band × duration), with a flat
-  // per-generation rate when a source video is supplied (V2V). Lowercase "4k".
-  if (effectiveProvider === "gemini-omni-video") {
+  // Gemini Omni family (gemini-omni-video + gemini-omni-flash): priced by
+  // (resolution-band × duration), with a flat per-generation rate when a source
+  // video is supplied (V2V). Lowercase "4k". The prefix is TEMPLATED from the
+  // provider id, so a further Omni SKU needs no edit here — it only has to join
+  // GEMINI_OMNI_PROVIDERS and seed its rows. These models are deliberately NOT
+  // in DURATION_PRICED_PROVIDERS; this branch early-returns before that gate.
+  if (isGeminiOmniProvider(effectiveProvider)) {
     if (hasVideoRef) {
-      return resolution === "4k" ? "gemini-omni-video:4k:vref" : "gemini-omni-video:vref"
+      return resolution === "4k" ? `${effectiveProvider}:4k:vref` : `${effectiveProvider}:vref`
     }
     // Snap to nearest allowed tier (NOT a min/max clamp) so off-tier durations
     // map to a SEEDED composite; default 8 when unset.
     const raw = parseInt(String(duration ?? 8), 10)
     const d = Number.isNaN(raw) ? 8 : GEMINI_OMNI_DURATIONS.reduce((b, a) => (Math.abs(a - raw) < Math.abs(b - raw) ? a : b))
-    return resolution === "4k" ? `gemini-omni-video:4k:${d}` : `gemini-omni-video:${d}`
+    return resolution === "4k" ? `${effectiveProvider}:4k:${d}` : `${effectiveProvider}:${d}`
   }
 
   // LTX 2.3: priced by (resolution-band × duration-seconds). The RESERVE must be
@@ -281,7 +290,31 @@ export function buildVideoCreditModelIdentifier(
   // guard fuzzes the whole resolution space.
   const resTiers = RESOLUTION_DURATION_PRICING[effectiveProvider]
   if (resTiers) {
-    const res = resolution && resTiers.includes(resolution) ? resolution : resTiers[0]!
+    // The "default tier" is the provider's DECLARED default when it has one
+    // (PRICING_DEFAULT_RESOLUTION — wan-3 renders 720p, not the cheapest tier),
+    // otherwise the first listed tier. Declaring it explicitly means a cosmetic
+    // reorder of the tier list can never reprice a live model, and an OMITTED
+    // *or* unsupported resolution both land on what actually renders instead of
+    // on the cheapest row (commit_credits refunds a surplus but can never
+    // collect a shortfall). Behaviour-neutral for every member without a
+    // declared default.
+    const declaredDefault = PRICING_DEFAULT_RESOLUTION[effectiveProvider]
+    const fallback = declaredDefault && resTiers.includes(declaredDefault) ? declaredDefault : resTiers[0]!
+    // Wan 3.0 renders through `normalizeWan3Resolution`, which is CASE-INSENSITIVE
+    // ("1080P" — KIE's own OpenAPI enum spelling, and the natural value for an
+    // integrator reading the provider docs — renders 1080P). The tier list here is
+    // lowercase and `Array.includes` is case-sensitive, so without this the render
+    // path and the billing path disagree: "1080P" rendered the top tier and billed
+    // the 720p row, a shortfall `commit_credits` (refund-only) can never collect.
+    // Collapsing through the SAME normalizer the runner uses makes render == billed
+    // by construction for every spelling, including garbage (→ the declared 720p).
+    // Scoped to the wan family on purpose: the other RESOLUTION_DURATION_PRICING
+    // members pass `resolution` to their wire verbatim, so case-folding their
+    // billing without probing their wire would reprice live models.
+    const requested = isWan3Provider(effectiveProvider)
+      ? normalizeWan3Resolution(resolution).toLowerCase()
+      : resolution
+    const res = requested && resTiers.includes(requested) ? requested : fallback
     identifier += `:${res}`
   }
 

package/src/i18n/held-prop.ar.ts

@@ -69,6 +69,8 @@ const map: LocaleCatalogMap = {
   "compass": { label: "بوصلة", description: "بوصلة بحرية محمولة، استكشاف" },
   "bow-and-arrow": { label: "قوس وسهم", description: "قوس مشدود بسهم متأهب" },
   "shield": { label: "درع", description: "درع محمول، عصور وسطى / خيال" },
+  // --- picker-gaps 2026-09-01 ---
+  "work-gloves": { label: "قفازات عمل", description: "قفازات عمل جلدية بالية ممسوكة باليد" },
 }
 
 export default map

package/src/i18n/held-prop.de.ts

@@ -60,6 +60,9 @@ const map: LocaleCatalogMap = {
   "compass": { label: "Kompass", description: "Handgehaltener nautischer Kompass, Erkundung" },
   "bow-and-arrow": { label: "Pfeil und Bogen", description: "Gespannter Bogen mit eingelegtem Pfeil" },
   "shield": { label: "Schild", description: "Handgehaltenes Schild, mittelalterlich / Fantasy" },
+
+  // --- picker-gaps 2026-09-01 ---
+  "work-gloves": { label: "Arbeitshandschuhe", description: "Abgetragene lederne Arbeitshandschuhe in der Hand gehalten" },
 }
 
 export default map

package/src/i18n/held-prop.es.ts

@@ -78,6 +78,9 @@ const map: LocaleCatalogMap = {
   "compass": { label: "Brújula", description: "Brújula náutica de mano, exploración" },
   "bow-and-arrow": { label: "Arco y Flecha", description: "Arco de tiro tensado con flecha encajada" },
   "shield": { label: "Escudo", description: "Escudo de mano, medieval / fantasía" },
+
+  // --- picker-gaps 2026-09-01 ---
+  "work-gloves": { label: "Guantes de Trabajo", description: "Guantes de cuero de trabajo desgastados sostenidos en la mano" },
 }
 
 export default map

package/src/i18n/held-prop.fr.ts

@@ -69,6 +69,8 @@ const map: LocaleCatalogMap = {
   "compass": { label: "Boussole", description: "Boussole nautique à main, exploration" },
   "bow-and-arrow": { label: "Arc et flèche", description: "Arc de tir à l'arc tendu avec flèche encochée" },
   "shield": { label: "Bouclier", description: "Bouclier porté à la main, médiéval / fantasy" },
+  // --- picker-gaps 2026-09-01 ---
+  "work-gloves": { label: "Gants de travail", description: "Gants de travail en cuir usés tenus à la main" },
 }
 
 export default map

package/src/i18n/held-prop.he.ts

@@ -68,6 +68,9 @@ const map: LocaleCatalogMap = {
   "compass": { label: "מצפן", description: "מצפן ימי מוחזק ביד, חקירה" },
   "bow-and-arrow": { label: "קשת וחץ", description: "קשת קשתות דרוכה עם חץ על המיתר" },
   "shield": { label: "מגן", description: "מגן מוחזק ביד, ימי הביניים / פנטזיה" },
+
+  // --- picker-gaps 2026-09-01 ---
+  "work-gloves": { label: "כפפות עבודה", description: "כפפות עבודה שחוקות מעור, מוחזקות ביד" },
 }
 
 export default map

package/src/i18n/held-prop.hi.ts

@@ -77,6 +77,8 @@ const map: LocaleCatalogMap = {
   "compass": { label: "कम्पास", description: "हाथ का nautical कम्पास, अन्वेषण" },
   "bow-and-arrow": { label: "धनुष-बाण", description: "तीर लगाया हुआ खींचा हुआ archery धनुष" },
   "shield": { label: "ढाल", description: "हाथ की ढाल, मध्यकालीन / fantasy" },
+  // --- picker-gaps 2026-09-01 ---
+  "work-gloves": { label: "काम के दस्ताने", description: "हाथ में पकड़े हुए घिसे चमड़े के काम के दस्ताने" },
 }
 
 export default map

package/src/i18n/held-prop.ja.ts

@@ -79,6 +79,9 @@ const map: LocaleCatalogMap = {
   "compass": { label: "コンパス", description: "手持ちの航海用コンパス、探検" },
   "bow-and-arrow": { label: "弓矢", description: "矢をつがえて引き絞った弓" },
   "shield": { label: "盾", description: "手持ちの盾、中世／ファンタジー" },
+
+  // --- picker-gaps 2026-09-01 ---
+  "work-gloves": { label: "作業用手袋", description: "手に持った使い込まれた革の作業用手袋" },
 }
 
 export default map