@nodaro/shared 2.5.0 → 2.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nodaro/shared",
-  "version": "2.5.0",
+  "version": "2.8.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__/entity-image-handle.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest"
-import { resolveEffectiveSourceType, ENTITY_IMAGE_HANDLE_TYPES, sourceRefKey } from "../entity-image-handle.js"
+import { resolveEffectiveSourceType, ENTITY_IMAGE_HANDLE_TYPES, AGGREGATE_LANE_SOURCE_TYPES, sourceRefKey } from "../entity-image-handle.js"
 
 const ENTITY_REF_HANDLE: Record<string, string> = {
   character: "characterRef",
@@ -62,3 +62,35 @@ describe("sourceRefKey (handle-scoped ref key — prevents node-id collision)",
     expect(sourceRefKey("n1", undefined, "character")).toBe("n1")
   })
 })
+
+describe("resolveEffectiveSourceType (aggregate lane handle → plain producer of that type)", () => {
+  const LANE_TO_PRODUCER: Record<string, string> = {
+    "out-image": "upload-image",
+    "out-video": "upload-video",
+    "out-audio": "upload-audio",
+    "out-text": "list",
+  }
+
+  it("remaps every Collect / Group lane to the plain producer of its media type", () => {
+    for (const agg of AGGREGATE_LANE_SOURCE_TYPES) {
+      for (const [lane, producer] of Object.entries(LANE_TO_PRODUCER)) {
+        expect(resolveEffectiveSourceType(agg, lane)).toBe(producer)
+      }
+    }
+  })
+
+  it("leaves a non-lane / missing handle as the raw aggregate type", () => {
+    expect(resolveEffectiveSourceType("collect", "out")).toBe("collect")
+    expect(resolveEffectiveSourceType("collect", undefined)).toBe("collect")
+    expect(resolveEffectiveSourceType("group", null)).toBe("group")
+  })
+
+  it("does not remap lane-shaped handles on non-aggregate producers", () => {
+    expect(resolveEffectiveSourceType("generate-image", "out-image")).toBe("generate-image")
+    expect(resolveEffectiveSourceType("list", "out-text")).toBe("list")
+  })
+
+  it("AGGREGATE_LANE_SOURCE_TYPES is exactly group + collect", () => {
+    expect([...AGGREGATE_LANE_SOURCE_TYPES].sort()).toEqual(["collect", "group"])
+  })
+})

package/src/__tests__/group-aggregation.test.ts

@@ -5,7 +5,9 @@ import {
   groupHandleId,
   parseGroupHandle,
   isAggregateableType,
+  computeAggregateLanes,
   AGGREGATEABLE_TYPES,
+  type AggregationBuckets,
   type Member,
 } from "../group-aggregation.js"
 
@@ -81,3 +83,40 @@ describe("isAggregateableType", () => {
     expect(isAggregateableType(undefined)).toBe(false)
   })
 })
+
+describe("computeAggregateLanes", () => {
+  const EMPTY: AggregationBuckets = { text: [], image: [], video: [], audio: [] }
+
+  it("returns empty when nothing is wired, bucketed, or referenced", () => {
+    expect(computeAggregateLanes("c1", [], EMPTY, [])).toEqual([])
+  })
+
+  it("exposes lanes for wired types even with empty buckets (pre-run)", () => {
+    expect(computeAggregateLanes("c1", ["image", "image"], EMPTY, [])).toEqual(["image"])
+  })
+
+  it("exposes lanes for bucket contents (post-run)", () => {
+    const buckets: AggregationBuckets = { text: ["t"], image: [], video: [], audio: [] }
+    expect(computeAggregateLanes("c1", [], buckets, [])).toEqual(["text"])
+  })
+
+  it("keeps a lane alive when an outgoing edge references it", () => {
+    const edges = [{ source: "c1", sourceHandle: "out-video" }]
+    expect(computeAggregateLanes("c1", [], EMPTY, edges)).toEqual(["video"])
+  })
+
+  it("ignores outgoing edges of other nodes and non-lane handles", () => {
+    const edges = [
+      { source: "other", sourceHandle: "out-video" },
+      { source: "c1", sourceHandle: "out" },
+      { source: "c1", sourceHandle: null },
+    ]
+    expect(computeAggregateLanes("c1", [], EMPTY, edges)).toEqual([])
+  })
+
+  it("unions all three sources and orders by AGGREGATEABLE_TYPES", () => {
+    const buckets: AggregationBuckets = { text: [], image: [], video: [], audio: ["a"] }
+    const edges = [{ source: "c1", sourceHandle: "out-video" }]
+    expect(computeAggregateLanes("c1", ["text"], buckets, edges)).toEqual(["text", "video", "audio"])
+  })
+})

package/src/__tests__/infer-music-video.test.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect } from "vitest"
+import { inferMusicVideo, videoAnalysisResultSchema, VIDEO_ANALYSIS_TIMES_OF_DAY, VIDEO_ANALYSIS_STORY_JUMPS } from "../video-analysis"
+
+/**
+ * The inference decides whether a recast takes the original soundtrack AS-IS
+ * (no stem separation). Server (recast route mode derivation) and client
+ * (prep pricing + the generate-time mode-mismatch guard) both call THIS
+ * function, so its exact boundary behaviour is contract, not detail.
+ */
+
+const music = (content: string) => ({ mode: "music" as const, content })
+const scene = (audio: Array<{ mode: string; content: string }>) => ({ audio })
+const vocalScenes = (n: number) => Array.from({ length: n }, () => scene([music("upbeat pop track with sung lyrics")]))
+
+describe("inferMusicVideo", () => {
+  it("true when ≥80% of ≥4 scenes carry music and vocals are evidenced", () => {
+    expect(inferMusicVideo({ scenes: vocalScenes(5) })).toBe(true)
+    // 4 of 5 with music (80% exactly), one vocal layer
+    expect(inferMusicVideo({ scenes: [...vocalScenes(4), scene([])] })).toBe(true)
+  })
+
+  it("quoted lyric text inside a music layer is vocal evidence on its own", () => {
+    const scenes = Array.from({ length: 4 }, () => scene([music('gentle track, "la la la, choosing you tonight"')]))
+    expect(inferMusicVideo({ scenes })).toBe(true)
+  })
+
+  it("false below the coverage bar, the scene floor, or with no vocal evidence", () => {
+    expect(inferMusicVideo({ scenes: [...vocalScenes(3), scene([]), scene([])] })).toBe(false) // 60%
+    expect(inferMusicVideo({ scenes: vocalScenes(3) })).toBe(false) // < 4 scenes
+    const instrumentalOnly = Array.from({ length: 5 }, () => scene([music("sweeping orchestral score")]))
+    expect(inferMusicVideo({ scenes: instrumentalOnly })).toBe(false)
+  })
+
+  it("negated vocals ('instrumental', 'no vocals') are not evidence; sfx/speech layers never are", () => {
+    const negated = Array.from({ length: 5 }, () => scene([music("instrumental version of the song, no vocals")]))
+    expect(inferMusicVideo({ scenes: negated })).toBe(false)
+    const speechy = Array.from({ length: 5 }, () => scene([{ mode: "speech", content: "she sings later" }, music("soft bed")]))
+    expect(inferMusicVideo({ scenes: speechy })).toBe(false)
+  })
+
+  it("bare 'song'/'music' descriptions are NOT vocal evidence (instrumental beds are described as songs)", () => {
+    const bare = Array.from({ length: 5 }, () => scene([music("upbeat pop song under the action")]))
+    expect(inferMusicVideo({ scenes: bare })).toBe(false)
+  })
+
+  it("throw-proof on malformed or absent input", () => {
+    expect(inferMusicVideo(undefined)).toBe(false)
+    expect(inferMusicVideo(null)).toBe(false)
+    expect(inferMusicVideo({})).toBe(false)
+    expect(inferMusicVideo({ scenes: [{}, { audio: [{}] }, {}, {}] } as never)).toBe(false)
+  })
+})
+
+describe("chronicle-time fields (2.6.0)", () => {
+  const base = {
+    startSec: 0, endSec: 2, label: "l", shotType: "Wide", camera: "static",
+    visual: "a scene", audio: [], sceneNumber: 1, visualResolved: "a scene", slotRefs: [],
+  }
+  const result = (sceneOver: Record<string, unknown>) => ({
+    meta: { durationSec: 2, width: 10, height: 10, aspectRatio: "1:1" },
+    slots: [],
+    scenes: [{ ...base, ...sceneOver }],
+  })
+
+  it("are optional (pre-2.6.0 analyses parse unchanged) and enum-validated when present", () => {
+    expect(videoAnalysisResultSchema.safeParse(result({})).success).toBe(true)
+    expect(videoAnalysisResultSchema.safeParse(result({ timeOfDay: "dusk", storyJump: "years-later" })).success).toBe(true)
+    expect(videoAnalysisResultSchema.safeParse(result({ timeOfDay: "noon" })).success).toBe(false)
+    expect(videoAnalysisResultSchema.safeParse(result({ storyJump: "later" })).success).toBe(false)
+  })
+
+  it("the enums stay congruence-safe for the window decode grammar (no ints, no maxItems)", () => {
+    expect(VIDEO_ANALYSIS_TIMES_OF_DAY).toContain("ambiguous")
+    expect(VIDEO_ANALYSIS_STORY_JUMPS).toContain("years-later")
+  })
+})

package/src/__tests__/llm-models.test.ts

@@ -6,12 +6,18 @@ import {
   LLM_REASONING_EFFORTS,
   getLlmModel,
   getLlmTier,
+  getLlmModalityCaps,
+  VIDEO_ANALYSIS_LLM_MODELS,
   buildLlmCreditIdentifier,
   resolveLlmCreditId,
   motionGraphicsFeature,
   effectiveReasoningEffort,
   supportsAdvancedMode,
   availableReasoningEfforts,
+  LLM_VENDOR_ORDER,
+  LLM_VENDOR_LABELS,
+  groupLlmModelsByVendor,
+  orderedLlmModels,
 } from "../llm-models.js"
 import type { LlmModelDef, LlmTier, LlmFeature } from "../llm-models.js"
 import { PIPELINE_PINNABLE_SCRIPT_LLMS } from "../pipeline-types.js"
@@ -28,6 +34,7 @@ import { PIPELINE_PINNABLE_SCRIPT_LLMS } from "../pipeline-types.js"
 const EXPECTED_MODEL_IDS = [
   "gemini-3-flash",
   "gemini-3.6-flash",
+  "gemini-3.7-flash",
   "claude-haiku-4.5",
   "claude-sonnet-4.6",
   "gpt-5.2",
@@ -38,6 +45,7 @@ const EXPECTED_MODEL_IDS = [
   "gpt-5.6-luna",
   "gpt-5.6-terra",
   "gpt-5.6-sol",
+  "grok-4.6",
   "claude-sonnet-5",
   "claude-opus-4.8",
   "claude-opus-5",
@@ -86,13 +94,13 @@ describe("LLM_MODELS data integrity", () => {
     expect(new Set(ids).size).toBe(ids.length)
   })
 
-  it("has 4 economy, 4 standard, 8 premium models", () => {
+  it("has 5 economy, 5 standard, 8 premium models", () => {
     const tierCounts: Record<LlmTier, number> = { economy: 0, standard: 0, premium: 0 }
     for (const model of LLM_MODELS) {
       tierCounts[model.tier]++
     }
-    expect(tierCounts.economy).toBe(4)
-    expect(tierCounts.standard).toBe(4)
+    expect(tierCounts.economy).toBe(5)
+    expect(tierCounts.standard).toBe(5)
     expect(tierCounts.premium).toBe(8)
   })
 
@@ -103,11 +111,12 @@ describe("LLM_MODELS data integrity", () => {
     expect(formats).toContain("responses")
   })
 
-  it("all three vendors are represented", () => {
+  it("all four vendors are represented", () => {
     const vendors = new Set(LLM_MODELS.map((m) => m.vendor))
     expect(vendors).toContain("anthropic")
     expect(vendors).toContain("google")
     expect(vendors).toContain("openai")
+    expect(vendors).toContain("xai")
   })
 
   it("all models support images", () => {
@@ -382,10 +391,11 @@ describe("LLM_FEATURE_DEFAULTS", () => {
     "generate-script",
     "translate",
     "image-critic",
+    "pick-best-llm",
   ]
 
-  it("has entries for all 15 features", () => {
-    expect(Object.keys(LLM_FEATURE_DEFAULTS)).toHaveLength(15)
+  it("has entries for all 16 features", () => {
+    expect(Object.keys(LLM_FEATURE_DEFAULTS)).toHaveLength(16)
     for (const feature of ALL_FEATURES) {
       expect(LLM_FEATURE_DEFAULTS).toHaveProperty(feature)
     }
@@ -471,6 +481,7 @@ describe("STRUCTURED_VISION_MODELS", () => {
         "claude-sonnet-4.6",
         "gemini-3-flash",
         "gemini-3.6-flash",
+        "gemini-3.7-flash",
         "gemini-3.1-pro",
         "claude-sonnet-5",
         "claude-opus-4.8",
@@ -483,15 +494,18 @@ describe("STRUCTURED_VISION_MODELS", () => {
         "gpt-5.6-luna",
         "gpt-5.6-terra",
         "gpt-5.6-sol",
+        // responses-format Grok — vision + text.format live-verified 2026-08-18.
+        "grok-4.6",
       ].sort(),
     )
   })
 
-  it("includes Anthropic (forced-tool), Gemini (response_format), and OpenAI (responses text.format) vendors", () => {
+  it("includes Anthropic (forced-tool), Gemini (response_format), and OpenAI/xAI (responses text.format) vendors", () => {
     const vendors = new Set(STRUCTURED_VISION_MODELS.map((m) => m.vendor))
     expect(vendors).toContain("anthropic")
     expect(vendors).toContain("google")
     expect(vendors).toContain("openai")
+    expect(vendors).toContain("xai")
   })
 
   it("excludes chat-completions GPT models — no native structured mode there (parse+retry only)", () => {
@@ -508,9 +522,9 @@ describe("STRUCTURED_VISION_MODELS", () => {
 })
 
 // ---------------------------------------------------------------------------
-// Reasoning effort registry (GPT-5.6 / Claude Sonnet 5 / Claude Opus 4.8)
-// grok-4.5 is DEFERRED — its chat endpoint is not live on the provider yet
-// (2026-07-13); its tests are intentionally omitted here.
+// Reasoning effort registry (GPT-5.6 / Claude Sonnet 5 / Claude Opus 4.8 /
+// Grok 4.6 — grok-4.5 was deferred on 2026-07-13 because its chat endpoint
+// wasn't live; grok-4.6 is its activation, live-verified 2026-08-18.)
 // ---------------------------------------------------------------------------
 describe("reasoning effort registry", () => {
   it("every reasoningEfforts list is a subset of the superset, in ascending order", () => {
@@ -525,6 +539,7 @@ describe("reasoning effort registry", () => {
     expect(getLlmTier("gpt-5.6-luna")).toBe("economy")
     expect(getLlmTier("gpt-5.6-terra")).toBe("standard")
     expect(getLlmTier("gpt-5.6-sol")).toBe("premium")
+    expect(getLlmTier("grok-4.6")).toBe("standard")
     expect(getLlmTier("claude-sonnet-5")).toBe("standard")
     expect(getLlmTier("claude-opus-4.8")).toBe("premium")
     expect(getLlmTier("gpt-5.5")).toBe("premium")
@@ -556,6 +571,62 @@ describe("reasoning effort registry", () => {
     expect(getLlmModel("claude-fable-5")?.reasoningEfforts).toEqual(["low", "medium", "high", "xhigh", "max"])
     expect(getLlmModel("claude-fable-5")?.directFallbackModel).toBe("claude-fable-5")
   })
+
+  it("grok-4.6: responses format on the grok family path, KIE's documented effort enum, no sampling params, reasons by default", () => {
+    const m = getLlmModel("grok-4.6")
+    expect(m?.vendor).toBe("xai")
+    expect(m?.kieFormat).toBe("responses")
+    expect(m?.kieSlugOrModel).toBe("grok-4-6")
+    expect(m?.structuredOutputMode).toBe("responses-json-schema")
+    // KIE's enum is low..xhigh with NO `none` — the endpoint reasons
+    // unconditionally (thinkingDefaultOn), so `none` would be a lie.
+    expect(m?.reasoningEfforts).toEqual(["low", "medium", "high", "xhigh"])
+    // Live-probed 2026-08-18: temperature is silently ignored — never send it.
+    expect(m?.supportsTemperature).toBe(false)
+    // Load-bearing: consumers floor max_tokens off this flag (a trivial probe
+    // spent 169/170 output tokens on reasoning with no reasoning param sent).
+    expect(m?.thinkingDefaultOn).toBe(true)
+    // KIE-only: no direct lane on either vendor SDK.
+    expect(m?.directFallbackModel).toBeUndefined()
+    expect(m?.directGeminiModel).toBeUndefined()
+  })
+
+  it("grok-4.6 resolves from its dash-form wire slug", () => {
+    expect(getLlmModel("grok-4-6")?.id).toBe("grok-4.6")
+  })
+})
+
+// ---------------------------------------------------------------------------
+// gemini-3.7-flash exposure (both lanes live-verified 2026-08-18: KIE
+// chat-completions with reasoning_effort + enforced response_format, and the
+// direct Google id resolving on generativelanguage)
+// ---------------------------------------------------------------------------
+describe("gemini-3.7-flash exposure", () => {
+  it("KIE-first chat-completions with a direct lane — 3.6-flash's proven shape", () => {
+    const m = getLlmModel("gemini-3.7-flash")
+    expect(m?.tier).toBe("economy")
+    expect(m?.vendor).toBe("google")
+    expect(m?.kieFormat).toBe("chat-completions")
+    expect(m?.kieSlugOrModel).toBe("gemini-3-7-flash-openai")
+    // KIE-first on purpose (no preferDirect): the cheap lane serves Generate
+    // Text; the direct lane is Advanced mode + the reliability fallback.
+    expect(m?.preferDirect).toBeUndefined()
+    expect(m?.directGeminiModel).toBe("gemini-3.7-flash")
+    expect(m?.reasoningEfforts).toEqual(["low", "high"])
+    expect(m?.structuredOutputMode).toBe("kie-response-format")
+    expect(supportsAdvancedMode("gemini-3.7-flash")).toBe(true)
+    expect(availableReasoningEfforts("gemini-3.7-flash", true)).toEqual(["none", "low", "medium", "high"])
+  })
+
+  it("stays OUT of video-analysis — image-only modality caps by decision, not omission", () => {
+    // Full video+audio caps would auto-enroll it in VIDEO_ANALYSIS_LLM_MODELS
+    // and force a VA tier + pricing decision that is deliberately deferred
+    // while the smart-family A/B routes this model internally (2026-08-18).
+    // If this test goes red, someone flipped the caps — that flip is only
+    // valid TOGETHER with the VA-side tier/pricing decision.
+    expect(getLlmModalityCaps("gemini-3.7-flash")).toEqual({ image: true, video: false, audio: false })
+    expect(VIDEO_ANALYSIS_LLM_MODELS).not.toContain("gemini-3.7-flash")
+  })
 })
 
 describe("effectiveReasoningEffort", () => {
@@ -583,6 +654,7 @@ describe("buildLlmCreditIdentifier effort bump (xhigh/max only)", () => {
   })
   it("standard + xhigh → premium", () => {
     expect(buildLlmCreditIdentifier("llm-chat", "gpt-5.6-terra", "xhigh")).toBe("llm-chat:premium")
+    expect(buildLlmCreditIdentifier("llm-chat", "grok-4.6", "xhigh")).toBe("llm-chat:premium")
   })
   it("premium + max stays premium", () => {
     expect(buildLlmCreditIdentifier("llm-chat", "gpt-5.6-sol", "max")).toBe("llm-chat:premium")
@@ -766,3 +838,58 @@ describe("lane-aware reasoning efforts", () => {
     expect(bad).toEqual([])
   })
 })
+
+// ---------------------------------------------------------------------------
+// Vendor grouping — the ONE ordering every LLM model menu renders
+// ---------------------------------------------------------------------------
+describe("groupLlmModelsByVendor / orderedLlmModels", () => {
+  it("every vendor in the union has an order slot AND a label (totality)", () => {
+    // A new vendor added to LlmVendor without a menu decision would silently
+    // sort its models to the end of every picker unlabeled — fail here instead.
+    const vendorsInUse = new Set(LLM_MODELS.map((m) => m.vendor))
+    for (const v of vendorsInUse) {
+      expect(LLM_VENDOR_ORDER, `vendor "${v}" missing from LLM_VENDOR_ORDER`).toContain(v)
+      expect(LLM_VENDOR_LABELS[v], `vendor "${v}" missing from LLM_VENDOR_LABELS`).toBeTruthy()
+    }
+    for (const v of LLM_VENDOR_ORDER) {
+      expect(LLM_VENDOR_LABELS[v]).toBeTruthy()
+    }
+  })
+
+  it("covers every model exactly once, in vendor order", () => {
+    const groups = groupLlmModelsByVendor()
+    const flattened = groups.flatMap((g) => g.models.map((m) => m.id))
+    expect(flattened.sort()).toEqual(LLM_MODELS.map((m) => m.id).sort())
+    expect(new Set(flattened).size).toBe(flattened.length)
+    const groupVendors = groups.map((g) => g.vendor)
+    expect(groupVendors).toEqual(LLM_VENDOR_ORDER.filter((v) => groupVendors.includes(v)))
+  })
+
+  it("inside each group models are tier-ordered economy → standard → premium", () => {
+    const rank = { economy: 0, standard: 1, premium: 2 } as const
+    for (const g of groupLlmModelsByVendor()) {
+      const ranks = g.models.map((m) => rank[m.tier])
+      expect(ranks, g.vendor).toEqual([...ranks].sort((a, b) => a - b))
+    }
+  })
+
+  it("groups carry their display label and omit empty groups after a filter", () => {
+    const groups = groupLlmModelsByVendor(LLM_MODELS.filter((m) => m.vendor === "xai"))
+    expect(groups).toHaveLength(1)
+    expect(groups[0].label).toBe("xAI")
+    expect(groups[0].models.map((m) => m.id)).toEqual(["grok-4.6"])
+  })
+
+  it("does not mutate the registry (registry order is load-bearing for LLM_MODEL_IDS)", () => {
+    const before = LLM_MODELS.map((m) => m.id)
+    groupLlmModelsByVendor()
+    orderedLlmModels()
+    expect(LLM_MODELS.map((m) => m.id)).toEqual(before)
+  })
+
+  it("orderedLlmModels is the flattened grouping", () => {
+    expect(orderedLlmModels().map((m) => m.id)).toEqual(
+      groupLlmModelsByVendor().flatMap((g) => g.models.map((m) => m.id)),
+    )
+  })
+})

package/src/__tests__/seedance-2-5-catalog.test.ts

@@ -23,10 +23,14 @@ const ID = "seedance-2-5"
  * api.kie.ai on 2026-08-08, NOT by the published schema — KIE's docs advertise
  * a wider surface than the proxy actually accepts. These tests pin the probed
  * reality so a future "the spec sheet says 4K/180s" edit has to re-probe first.
+ *
+ * Re-probed 2026-08-17 (KIE "Seedance 2.5 now supports 1080P" release):
+ * 1080p passes resolution validation; 1440p/2k/4k are still rejected with
+ * "not within the range of allowed options", and duration 31 is still refused.
  */
-describe("seedance-2-5 catalog (probe-verified 2026-08-08)", () => {
-  it("is 480p/720p ONLY — KIE rejects 1080p/4k/2k the same way it rejects a nonsense value", () => {
-    expect(MODEL_CATALOG[ID].resolutions).toEqual(["480p", "720p"])
+describe("seedance-2-5 catalog (probe-verified 2026-08-08, re-probed 2026-08-17)", () => {
+  it("is 480p/720p/1080p — KIE still rejects 4k/2k/1440p the same way it rejects a nonsense value", () => {
+    expect(MODEL_CATALOG[ID].resolutions).toEqual(["480p", "720p", "1080p"])
   })
 
   it("runs 4-30s contiguously — 30 is the probed ceiling (31 was rejected)", () => {
@@ -101,9 +105,13 @@ describe("seedance-2-5 pricing identifiers", () => {
     }
   })
 
+  it("prices 1080p at its own tier — a supported resolution must never clamp away", () => {
+    expect(build(8, "1080p")).toBe("seedance-2-5:8s:1080p")
+    expect(build(30, "1080p")).toBe("seedance-2-5:30s:1080p")
+  })
+
   it("clamps an unsupported resolution to the top real tier so the id is always seeded", () => {
-    expect(build(8, "1080p")).toBe("seedance-2-5:8s:720p")
-    expect(build(8, "4k")).toBe("seedance-2-5:8s:720p")
+    expect(build(8, "4k")).toBe("seedance-2-5:8s:1080p")
   })
 
   it("selects the cheaper -ref ladder when a reference video is wired", () => {
@@ -114,7 +122,7 @@ describe("seedance-2-5 pricing identifiers", () => {
   it("resolves every catalog duration x resolution x ref-mode to a distinct tier", () => {
     const seen = new Set<string>()
     for (const d of MODEL_CATALOG[ID].durations!) {
-      for (const res of ["480p", "720p"]) {
+      for (const res of ["480p", "720p", "1080p"]) {
         for (const ref of [false, true]) {
           const identifier = build(d, res, ref)
           expect(identifier).toBe(`${ID}:${d}s:${res}${ref ? "-ref" : ""}`)
@@ -122,7 +130,7 @@ describe("seedance-2-5 pricing identifiers", () => {
         }
       }
     }
-    // 27 durations x 2 resolutions x 2 ref-modes, none collapsing onto another.
-    expect(seen.size).toBe(108)
+    // 27 durations x 3 resolutions x 2 ref-modes, none collapsing onto another.
+    expect(seen.size).toBe(162)
   })
 })

package/src/entity-image-handle.ts

@@ -19,11 +19,41 @@ export const ENTITY_IMAGE_HANDLE_TYPES: ReadonlySet<string> = new Set([
   "creature",
 ])
 
+/**
+ * Aggregate node types (Group / Collect) whose source handles are typed LANES
+ * — `out-text` / `out-image` / `out-video` / `out-audio` — each emitting that
+ * media type. Like an entity's `image` handle, a wire leaving a lane is a plain
+ * producer of that lane's type, so it must reach the typed inputs of every
+ * consumer (Image Collage, Combine Videos, Merge Lists, prompts, …) exactly as
+ * an upload node of that type would. Neither node type is in any producer set
+ * itself: the NODE emits nothing, its LANES do.
+ */
+export const AGGREGATE_LANE_SOURCE_TYPES: ReadonlySet<string> = new Set(["group", "collect"])
+
+/**
+ * The plain producer each aggregate lane behaves as. `upload-*` are the
+ * canonical single-media producers present in every typed accepts set
+ * (IMAGE/VIDEO/AUDIO_PRODUCER_TYPES). `out-text` maps to `list`, not
+ * `text-prompt`: the lane is a LIST of texts, so it must reach both prompt
+ * inputs (TEXT_PRODUCER_TYPES) and the list consumers (Merge Lists / Sort /
+ * Dedup / Selector — LIST_PRODUCER_TYPES), exactly like a List text column.
+ * (`list` is also a DYNAMIC producer, so the text lane is admitted at media
+ * inputs too — the same latitude a List column already has on canvas.)
+ */
+const AGGREGATE_LANE_EFFECTIVE_TYPE: Readonly<Record<string, string>> = {
+  "out-image": "upload-image",
+  "out-video": "upload-video",
+  "out-audio": "upload-audio",
+  "out-text": "list",
+}
+
 /**
  * The effective output TYPE a given source handle emits. Returns the raw node
- * type for every `(type, handle)` pair EXCEPT an entity `image` handle, which
- * resolves to `"upload-image"` (a plain image producer). Pure — safe for both
- * frontend and backend.
+ * type for every `(type, handle)` pair EXCEPT:
+ *   - an entity `image` handle → `"upload-image"` (a plain image producer);
+ *   - an aggregate (group / collect) lane handle → the plain producer of that
+ *     lane's media type (see AGGREGATE_LANE_EFFECTIVE_TYPE).
+ * Pure — safe for both frontend and backend.
  */
 export function resolveEffectiveSourceType(
   rawSourceType: string | undefined | null,
@@ -32,6 +62,10 @@ export function resolveEffectiveSourceType(
   if (sourceHandleId === "image" && ENTITY_IMAGE_HANDLE_TYPES.has(rawSourceType ?? "")) {
     return "upload-image"
   }
+  if (AGGREGATE_LANE_SOURCE_TYPES.has(rawSourceType ?? "")) {
+    const effective = AGGREGATE_LANE_EFFECTIVE_TYPE[sourceHandleId ?? ""]
+    if (effective) return effective
+  }
   return rawSourceType ?? ""
 }
 

package/src/group-aggregation.ts

@@ -73,3 +73,35 @@ export function buildChildrenByParent<N extends { id: string; parentId?: string
 export function isCollectInEdge(e: { targetHandle?: string | null }): boolean {
   return (e.targetHandle ?? COLLECT_IN_HANDLE) === COLLECT_IN_HANDLE
 }
+
+/**
+ * The source-pip lanes an aggregate node (Group / Collect) must EXPOSE.
+ *
+ * Bucket contents alone are not enough: buckets are computed from upstream
+ * RESULTS, so before anything ran the node rendered zero source handles — a
+ * pre-authored edge out of the node (MCP-written JSON, import, paste) pointed
+ * at a handle that did not exist and React Flow silently hid it ("connected
+ * in the panel, invisible on canvas"), and there was no pip to drag outward
+ * from. A lane therefore exists when ANY of these hold:
+ *   (a) a wired member / input of that aggregateable type exists (pre-run),
+ *   (b) the bucket for that type has values (post-run),
+ *   (c) an existing outgoing edge references the lane's handle — so an edge
+ *       can never point at a missing handle, whatever state authored it
+ *       (also covers results being cleared after wiring downstream).
+ * Ordered by AGGREGATEABLE_TYPES so the handle layout is stable.
+ */
+export function computeAggregateLanes(
+  nodeId: string,
+  wiredTypes: Iterable<AggregateableType>,
+  buckets: AggregationBuckets,
+  edges: ReadonlyArray<{ source: string; sourceHandle?: string | null }>,
+): AggregateableType[] {
+  const present = new Set<AggregateableType>(wiredTypes)
+  for (const t of presentTypes(buckets)) present.add(t)
+  for (const e of edges) {
+    if (e.source !== nodeId) continue
+    const lane = parseGroupHandle(e.sourceHandle)
+    if (lane) present.add(lane)
+  }
+  return AGGREGATEABLE_TYPES.filter((t) => present.has(t))
+}

package/src/index.ts

@@ -62,6 +62,7 @@ export {
   IMAGE_GEN_PROVIDERS,
   IMAGE_I2I_PROVIDERS,
   IMAGE_EDIT_PROVIDERS,
+  TASK_CHAINED_EDIT_PROVIDERS,
   IMAGE_TO_VIDEO_PROVIDERS,
   TEXT_TO_VIDEO_PROVIDERS,
   VIDEO_GEN_PROVIDERS,
@@ -270,6 +271,7 @@ export {
   parseGroupHandle,
   isCollectInEdge,
   buildChildrenByParent,
+  computeAggregateLanes,
   type AggregateableType,
   type Member,
   type AggregationBuckets,
@@ -279,6 +281,12 @@ export {
   LLM_MODELS,
   LLM_MODEL_IDS,
   STRUCTURED_VISION_MODELS,
+  LLM_VENDOR_ORDER,
+  LLM_VENDOR_LABELS,
+  groupLlmModelsByVendor,
+  orderedLlmModels,
+  type LlmVendor,
+  type LlmModelGroup,
   VIDEO_ANALYSIS_LLM_MODELS,
   VIDEO_ANALYSIS_TIERS,
   VIDEO_ANALYSIS_LEGACY_MODELS,