@nodaro/shared 3.8.0 → 3.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nodaro/shared",
-  "version": "3.8.0",
+  "version": "3.10.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__/credit-identifiers.test.ts

@@ -132,7 +132,7 @@ describe("buildCreditModelIdentifier", () => {
 
   // --- Ideogram providers ---
   describe("ideogram providers", () => {
-    const ideogramProviders = ["ideogram-edit", "ideogram-remix", "ideogram-reframe", "ideogram-v3"]
+    const ideogramProviders = ["ideogram-edit", "ideogram-remix", "ideogram-v3"]
 
     it.each(ideogramProviders)(
       '%s + renderingSpeed="TURBO" returns composite identifier',
@@ -230,6 +230,56 @@ describe("buildCreditModelIdentifier", () => {
     it("does not affect non-flux-2 providers", () => {
       expect(buildCreditModelIdentifier("nano-banana", undefined, undefined, undefined, undefined, 4)).toBe("nano-banana")
     })
+
+    // ── Off-grid resolutions ────────────────────────────────────────────────
+    // Flux 2 is the ONLY family whose identifier interpolates `resolution`
+    // rather than matching it, and its callers legitimately hand it another
+    // model's value space: the multi-provider cost preview prices ONE node's
+    // data against EVERY selected provider (frontend
+    // `ee/hooks/use-providers-credits-sum.ts`), and node data written straight
+    // into workflow JSON by an agent/import/template never ran the config
+    // panel's provider-change fail-safe. "2K" used to interpolate into
+    // "flux-2-pro:2KMP:0ref" — an id no pricing row can answer, so every cost
+    // badge 503'd price_not_configured (18 production app-reports 2026-09-07..14).
+    it.each([
+      ["flux-2-pro", "2K", "flux-2-pro:2MP:0ref"],
+      ["flux-2-max", "2K", "flux-2-max:2MP:0ref"],
+      ["flux-2-klein", "2K", "flux-2-klein:1MP:0ref"],
+      ["flux-2-pro", "4K", "flux-2-pro:2MP:0ref"],
+      ["flux-2-pro", "1080p", "flux-2-pro:2MP:0ref"],
+      // Empty string is "unset", not a foreign value — it must not emit ":MP:".
+      ["flux-2-pro", "", "flux-2-pro:1MP:0ref"],
+    ])("%s + off-grid resolution %p snaps to the model default", (model, resolution, expected) => {
+      expect(buildCreditModelIdentifier(model, undefined, resolution)).toBe(expected)
+    })
+
+    it("an off-grid resolution keeps the ref count", () => {
+      expect(buildCreditModelIdentifier("flux-2-max", undefined, "2K", undefined, undefined, 3)).toBe("flux-2-max:2MP:3ref")
+    })
+
+    it("a same-value different-spelling resolution keeps its tier, in the grid's spelling", () => {
+      // "2.0 MP" is the same point on the grid as "2 MP" — snapping it to the
+      // model default would silently re-price a correct node — but the id must
+      // still read ":2MP:", the spelling the pricing rows are keyed on.
+      expect(buildCreditModelIdentifier("flux-2-klein", undefined, "2.0 MP")).toBe("flux-2-klein:2MP:0ref")
+      expect(buildCreditModelIdentifier("flux-2-klein", undefined, " 2 ")).toBe("flux-2-klein:2MP:0ref")
+      expect(buildCreditModelIdentifier("flux-2-klein", undefined, "0.5")).toBe("flux-2-klein:0.5MP:0ref")
+    })
+
+    it("the snap agrees with the route: normalize-then-build === build", () => {
+      // resolveNormalizedImageGen (routes + orchestrator) snaps "2K" through
+      // normalizeModelInput BEFORE building. The badge builds directly. Both
+      // must land on the same id or the preview quotes a price the reserve
+      // will not charge.
+      for (const provider of ["flux-2-klein", "flux-2-pro", "flux-2-max"]) {
+        for (const resolution of ["2K", "4K", "1K"]) {
+          expect(
+            resolveNormalizedImageGen({ provider, resolution, refCount: 0 }).identifier,
+            `${provider} + ${resolution}`,
+          ).toBe(buildCreditModelIdentifier(provider, undefined, resolution))
+        }
+      }
+    })
   })
 })
 

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

@@ -41,13 +41,21 @@ describe("GVP_SUPPORTED_PROVIDERS", () => {
     // Not a hand-kept list any more — this pin documents the CURRENT result so
     // a catalog edit that changes the offered SKUs is visible in review, while
     // the derivation itself is what ships.
+    //
+    // `veo3` (VEO 3.1 QUALITY) LEFT the set on 2026-09-15 and the removal is
+    // the derivation working: the bar is "takes a generated start still AND
+    // can carry the identity/continuity reference images the anchor wave
+    // attaches", and KIE serves reference-to-video on the Fast and Lite SKUs
+    // only ("Reference to video only supports the Veo Fast model and Veo Lite
+    // model.", production 2026-09-04). A Quality run that reached the anchor
+    // wave with identity refs was a 422 mid-render, after the credits for a
+    // multi-segment job were reserved. The Fast and Lite SKUs stay.
     expect([...GVP_SUPPORTED_PROVIDERS]).toEqual([
       "seedance-2",
       "seedance-2-fast",
       "seedance-2-mini",
       "seedance-2-5",
       "minimax-h3",
-      "veo3",
       "veo3.1",
       "veo3_lite",
       "gemini-omni-video",
@@ -121,6 +129,12 @@ describe("GVP_SUPPORTED_PROVIDERS", () => {
     expect(isGvpSupportedProvider("hailuo-2.3-pro")).toBe(false)
     expect(isGvpSupportedProvider("bytedance-pro")).toBe(false)
     expect(isGvpSupportedProvider("grok-imagine-video-1.5")).toBe(false)
+    // VEO 3.1 Quality joins them: i2v and segmentable, but no reference
+    // transport at KIE (Fast/Lite only), so the anchor wave has nowhere to
+    // put identity refs.
+    expect(isGvpSupportedProvider("veo3")).toBe(false)
+    expect(isGvpSupportedProvider("veo3.1")).toBe(true)
+    expect(isGvpSupportedProvider("veo3_lite")).toBe(true)
     // Not i2v at all.
     expect(isGvpSupportedProvider("seedance-2-extend")).toBe(false)
     expect(isGvpSupportedProvider("runway-aleph")).toBe(false)
@@ -170,7 +184,7 @@ describe("GVP_EXTEND_PROVIDERS", () => {
   })
 
   it("keyframes-only SKUs reject extend", () => {
-    for (const p of ["veo3", "veo3.1", "veo3_lite", "gemini-omni-video", "gemini-omni-flash", "grok-i2v", "happyhorse-ref2v", "wan-3", "wan-3-prime"]) {
+    for (const p of ["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)
     }
@@ -186,7 +200,10 @@ describe("GVP_END_FRAME_PROVIDERS", () => {
       "seedance-2-mini",
       "seedance-2-5",
       "minimax-h3",
-      "veo3",
+      // `veo3` is absent because GVP_END_FRAME_PROVIDERS is a subset of
+      // GVP_SUPPORTED_PROVIDERS, which VEO 3.1 Quality left — see above. The
+      // catalog still declares "end-frame" for the SKU; it is simply not a
+      // pro-node SKU any more.
       "veo3.1",
       "veo3_lite",
       "wan-3",

package/src/__tests__/model-catalog-sections.test.ts

@@ -0,0 +1,59 @@
+import { describe, it, expect } from "vitest"
+import { MODEL_CATALOG, MODEL_KINDS, groupByKindAndFamily, listModels } from "../model-catalog.js"
+
+/**
+ * The Image / Video / Audio envelope of every model-discovery surface.
+ *
+ * #1332: `GET /v1/models` and MCP `list_models` grouped by family FIRST and
+ * let the family's first model pick the section, so a vendor that ships more
+ * than one kind — Google (Imagen + VEO), ByteDance (Seedream + Seedance),
+ * Alibaba, xAI — was filed whole under whichever kind came first in catalog
+ * order: 23 video models shipped under "image" whenever the call carried no
+ * `kind` filter. The invariant that was missing: every model appears in the
+ * section of its OWN kind.
+ */
+describe("groupByKindAndFamily", () => {
+  const all = listModels({})
+  const sections = groupByKindAndFamily(all)
+
+  it("files every catalog model under the section of its own kind", () => {
+    for (const section of sections) {
+      for (const { models } of section.families) {
+        for (const m of models) expect(m.kind, `${m.id} filed under "${section.kind}"`).toBe(section.kind)
+      }
+    }
+  })
+
+  it("loses nothing and duplicates nothing", () => {
+    const filed = sections.flatMap((s) => s.families.flatMap((f) => f.models.map((m) => m.id))).sort()
+    expect(filed).toEqual(all.map((m) => m.id).sort())
+  })
+
+  it("a vendor that ships more than one kind appears once per kind — VEO is video, Imagen is image", () => {
+    const familiesOf = (kind: string) => sections.find((s) => s.kind === kind)?.families.map((f) => f.family) ?? []
+    expect(familiesOf("video")).toContain("Google")
+    expect(familiesOf("image")).toContain("Google")
+    const videoIds = sections.find((s) => s.kind === "video")!.families.flatMap((f) => f.models.map((m) => m.id))
+    for (const id of ["veo3", "veo3.1", "seedance-2", "seedance-2-5", "wan-3", "grok-i2v"]) {
+      if (MODEL_CATALOG[id]) expect(videoIds, id).toContain(id)
+    }
+    const imageIds = sections.find((s) => s.kind === "image")!.families.flatMap((f) => f.models.map((m) => m.id))
+    for (const id of videoIds) expect(imageIds).not.toContain(id)
+  })
+
+  it("keeps the fixed image → video → audio order and omits an empty section", () => {
+    expect(sections.map((s) => s.kind)).toEqual([...MODEL_KINDS])
+    expect(groupByKindAndFamily(all.filter((m) => m.kind === "audio")).map((s) => s.kind)).toEqual(["audio"])
+    expect(groupByKindAndFamily([])).toEqual([])
+  })
+
+  it("one spelling per vendor — a family name never differs from another only by case", () => {
+    const byLower = new Map<string, Set<string>>()
+    for (const m of all) {
+      const set = byLower.get(m.family.toLowerCase()) ?? new Set<string>()
+      set.add(m.family)
+      byLower.set(m.family.toLowerCase(), set)
+    }
+    for (const [, spellings] of byLower) expect([...spellings], [...spellings].join(" / ")).toHaveLength(1)
+  })
+})

package/src/__tests__/model-tree.test.ts

@@ -10,6 +10,9 @@ describe("modelToNodeTarget", () => {
     expect(modelToNodeTarget("suno")).toEqual({ nodeType: "suno-generate", field: "model", value: "V4" })
     expect(modelToNodeTarget("suno-v5")).toEqual({ nodeType: "suno-generate", field: "model", value: "V5" })
     expect(modelToNodeTarget("suno-v5_5")).toEqual({ nodeType: "suno-generate", field: "model", value: "V5_5" })
+    expect(modelToNodeTarget("suno-v6")).toEqual({ nodeType: "suno-generate", field: "model", value: "V6" })
+    expect(modelToNodeTarget("suno-v6_wild")).toEqual({ nodeType: "suno-generate", field: "model", value: "V6_WILD" })
+    expect(modelToNodeTarget("suno-v6_mini")).toEqual({ nodeType: "suno-generate", field: "model", value: "V6_MINI" })
   })
   // `elevenlabs-dubbing` is a single-provider utility whose id is NOT in any
   // provider-enum array, so it exercises the modes fallback → bare node, no preset.
@@ -23,8 +26,8 @@ describe("modelToNodeTarget", () => {
   it("returns a provider preset for an enum video model (gemini-omni-video is enum-valid)", () => {
     expect(modelToNodeTarget("gemini-omni-video")).toEqual({ nodeType: "generate-video", field: "provider", value: "gemini-omni-video" })
   })
-  it("returns null when there is no node (voice-clone) or unknown id", () => {
-    expect(modelToNodeTarget("voice-clone")).toBeNull()
+  it("returns null when there is no node (video-audit) or unknown id", () => {
+    expect(modelToNodeTarget("video-audit")).toBeNull()
     expect(modelToNodeTarget("totally-unknown")).toBeNull()
   })
   it("never targets suno-generate without a model value (every music model carries dataValue)", () => {

package/src/__tests__/parameter-node-value.test.ts

@@ -1,6 +1,8 @@
 import { describe, it, expect, afterEach } from "vitest"
 import {
   PARAMETER_NODE_TYPES,
+  VIDEO_ONLY_PARAMETER_NODE_TYPES,
+  EXECUTION_GRAPH_COMPOSED_PARAMETER_TYPES,
   getParameterValue,
 } from "../parameter-node-value.js"
 import { setRegisteredPersonPackFields } from "../index.js"
@@ -123,6 +125,39 @@ describe("getParameterValue — character-fx", () => {
   })
 })
 
+describe("getParameterValue — character-motion", () => {
+  it("returns the id for a single string value", () => {
+    expect(getParameterValue({ characterMotion: "wave-hello" }, "character-motion")).toBe("wave-hello")
+  })
+  it("returns the first id of an ordered multi-pick", () => {
+    expect(getParameterValue({ characterMotion: ["walk-in-from-left", "wave-hello"] }, "character-motion")).toBe("walk-in-from-left")
+  })
+  it("returns undefined for empty string / empty array", () => {
+    expect(getParameterValue({ characterMotion: "" }, "character-motion")).toBeUndefined()
+    expect(getParameterValue({ characterMotion: [] }, "character-motion")).toBeUndefined()
+  })
+  it("character-motion is a parameter node", () => {
+    expect(PARAMETER_NODE_TYPES.has("character-motion")).toBe(true)
+  })
+})
+
+describe("VIDEO_ONLY_PARAMETER_NODE_TYPES", () => {
+  it("names exactly the pickers a still image must never receive", () => {
+    expect([...VIDEO_ONLY_PARAMETER_NODE_TYPES].sort()).toEqual(
+      ["camera-motion", "character-fx", "character-motion", "temporal", "transition"],
+    )
+  })
+  it("is a subset of PARAMETER_NODE_TYPES", () => {
+    for (const t of VIDEO_ONLY_PARAMETER_NODE_TYPES) expect(PARAMETER_NODE_TYPES.has(t), t).toBe(true)
+  })
+})
+
+describe("EXECUTION_GRAPH_COMPOSED_PARAMETER_TYPES", () => {
+  it("names the pickers whose fragment needs the graph at execution", () => {
+    expect([...EXECUTION_GRAPH_COMPOSED_PARAMETER_TYPES].sort()).toEqual(["camera-motion", "character-motion"])
+  })
+})
+
 describe("parameter-node-value — furniture", () => {
   it("includes furniture in PARAMETER_NODE_TYPES set", () => {
     expect(PARAMETER_NODE_TYPES.has("furniture")).toBe(true)

package/src/__tests__/pricing-default-duration.test.ts

@@ -0,0 +1,45 @@
+import { describe, it, expect } from "vitest"
+import { PRICING_DEFAULT_DURATION_SEC, pricedOutputDurationSec } from "../model-constants.js"
+import { buildVideoCreditModelIdentifier } from "../credit-identifiers.js"
+
+/**
+ * #1397: a request that names a provider but omits `duration` renders the
+ * provider's OWN default, so it must be priced — identifier tier AND every
+ * reservation that scales by output seconds — at that default, never at a
+ * literal 5. `pricedOutputDurationSec` is the one source both read.
+ */
+describe("pricedOutputDurationSec", () => {
+  it("the requested duration wins, as a number or a numeric string", () => {
+    expect(pricedOutputDurationSec("seedance-2-5", 12)).toBe(12)
+    expect(pricedOutputDurationSec("seedance-2-5", "12")).toBe(12)
+    expect(pricedOutputDurationSec("minimax-h3", 4)).toBe(4)
+  })
+
+  it("an omitted duration prices the provider's declared default render length", () => {
+    expect(pricedOutputDurationSec("seedance-2-5", undefined)).toBe(8)
+    expect(pricedOutputDurationSec("grok-imagine-video-1.5", undefined)).toBe(8)
+    expect(pricedOutputDurationSec("minimax-h3", undefined)).toBe(6)
+    expect(PRICING_DEFAULT_DURATION_SEC["seedance-2-5"]).toBe(8)
+  })
+
+  it("a provider with no declared default keeps the historical 5s fallback", () => {
+    expect(pricedOutputDurationSec("seedance-2", undefined)).toBe(5)
+    expect(pricedOutputDurationSec("kling", undefined)).toBe(5)
+  })
+
+  it("an unparseable duration falls back the same way", () => {
+    expect(pricedOutputDurationSec("seedance-2-5", "abc")).toBe(8)
+    expect(pricedOutputDurationSec("seedance-2", "abc")).toBe(5)
+  })
+
+  it("the identifier tier for an omitted duration is the default's tier, not the 5s one (seedance-2-5)", () => {
+    for (const nodeType of ["image-to-video", "text-to-video"] as const) {
+      expect(buildVideoCreditModelIdentifier("seedance-2-5", undefined, undefined, nodeType, undefined, "720p")).toBe(
+        buildVideoCreditModelIdentifier("seedance-2-5", 8, undefined, nodeType, undefined, "720p"),
+      )
+      expect(buildVideoCreditModelIdentifier("seedance-2-5", undefined, undefined, nodeType, undefined, "720p", true)).toBe(
+        "seedance-2-5:8s:720p-ref",
+      )
+    }
+  })
+})

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

@@ -40,6 +40,10 @@ describe("per-model prompt length limits", () => {
       expect(getMaxImagePromptChars("seedream-5-lite")).toBe(1000)
       expect(getMaxImagePromptChars("qwen")).toBe(3000)
       expect(getMaxImagePromptChars("qwen-edit")).toBe(2000)
+      // The shortest of the family. Listing it as the 5000 default is what sent
+      // three prod runs (2026-09-07) into KIE's "The text length cannot exceed
+      // the maximum limit".
+      expect(getMaxImagePromptChars("z-image")).toBe(1000)
     })
     it("siblings differ — does not copy the t2i number to i2i/edit", () => {
       // seedream t2i 3000, 5-lite t2i 1000 but its i2i is 3000