@nodaro/shared 2.7.0 → 2.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nodaro/shared",
-  "version": "2.7.0",
+  "version": "2.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__/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", () => {
@@ -383,10 +392,11 @@ describe("LLM_FEATURE_DEFAULTS", () => {
     "translate",
     "image-critic",
     "pick-best-llm",
+    "workflow-copilot",
   ]
 
-  it("has entries for all 16 features", () => {
-    expect(Object.keys(LLM_FEATURE_DEFAULTS)).toHaveLength(16)
+  it("has entries for all 17 features", () => {
+    expect(Object.keys(LLM_FEATURE_DEFAULTS)).toHaveLength(17)
     for (const feature of ALL_FEATURES) {
       expect(LLM_FEATURE_DEFAULTS).toHaveProperty(feature)
     }
@@ -472,6 +482,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",
@@ -484,15 +495,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)", () => {
@@ -509,9 +523,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", () => {
@@ -526,6 +540,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")
@@ -557,6 +572,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", () => {
@@ -584,6 +655,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")
@@ -767,3 +839,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__/organizations-types.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from "vitest"
+import {
+  ACCESS_LEVELS,
+  COLLABORATOR_ROLES,
+  MEMBER_STATUSES,
+  ORG_ERROR_CODES,
+  ORG_KINDS,
+  ORG_ROLES,
+  OrgSettingsSchema,
+  PRESET_SETTING_KEYS,
+  PresetSettingsSchema,
+  WORKSPACE_ROLES,
+  WorkspaceSettingsSchema,
+} from "../organizations/index.js"
+
+describe("organizations wire contract — enums", () => {
+  it("every enum is non-empty and duplicate-free", () => {
+    for (const list of [ORG_KINDS, ORG_ROLES, WORKSPACE_ROLES, MEMBER_STATUSES, COLLABORATOR_ROLES, ACCESS_LEVELS, ORG_ERROR_CODES]) {
+      expect(list.length).toBeGreaterThan(0)
+      expect(new Set(list).size).toBe(list.length)
+    }
+  })
+
+  it("error codes are snake_case identifiers", () => {
+    for (const code of ORG_ERROR_CODES) expect(code).toMatch(/^[a-z][a-z_]*[a-z]$/)
+  })
+})
+
+describe("organizations wire contract — settings request schemas", () => {
+  it("the preset shape has exactly the nine resolvable keys", () => {
+    expect([...PRESET_SETTING_KEYS].sort()).toEqual(
+      [
+        "admin_access",
+        "collaborators_can_invite",
+        "default_workflow_visibility",
+        "member_access_to_shared",
+        "member_caps_enabled",
+        "members_can_create_projects",
+        "personal_space_enabled",
+        "policy_survives_suspension",
+        "workspace_admins_can_invite",
+      ].sort(),
+    )
+    expect(PresetSettingsSchema.safeParse({}).success).toBe(false)
+  })
+
+  it("workspace settings are a partial of the preset; unknown keys are stripped; bad values rejected", () => {
+    expect(WorkspaceSettingsSchema.parse({ admin_access: "edit", rogue: 1 })).toEqual({ admin_access: "edit" })
+    expect(WorkspaceSettingsSchema.safeParse({}).success).toBe(true)
+    expect(WorkspaceSettingsSchema.safeParse({ admin_access: "owner" }).success).toBe(false)
+    expect(WorkspaceSettingsSchema.safeParse({ member_caps_enabled: "yes" }).success).toBe(false)
+  })
+
+  it("org settings accept lower-case domains only and string vocabulary overrides", () => {
+    expect(OrgSettingsSchema.safeParse({ allowed_email_domains: ["school.edu", "sub.school.ac.il"] }).success).toBe(true)
+    expect(OrgSettingsSchema.safeParse({ allowed_email_domains: ["School.edu"] }).success).toBe(false)
+    expect(OrgSettingsSchema.safeParse({ allowed_email_domains: ["not a domain"] }).success).toBe(false)
+    expect(OrgSettingsSchema.safeParse({ vocabulary_overrides: { workspace: "Cohort" } }).success).toBe(true)
+    expect(OrgSettingsSchema.safeParse({ vocabulary_overrides: { workspace: 3 } }).success).toBe(false)
+  })
+})

package/src/__tests__/producer-types.test.ts

@@ -23,6 +23,17 @@ describe("producer-types", () => {
     DYNAMIC_PRODUCER_TYPES,
   } as const
 
+  // still-to-video (still image + audio → MP4 via local FFmpeg) has a video
+  // OUTPUT handle — absent from this set, every downstream video input would
+  // hard-reject its edges (the "cannot connect the outputs" bug class).
+  it("registers still-to-video as a video producer", () => {
+    expect(VIDEO_PRODUCER_TYPES.has("still-to-video")).toBe(true)
+  })
+
+  it("registers slideshow as a video producer (still-to-video's N-image companion)", () => {
+    expect(VIDEO_PRODUCER_TYPES.has("slideshow")).toBe(true)
+  })
+
   it("registers voice-changer-pro as an audio producer (its default output)", () => {
     expect(AUDIO_PRODUCER_TYPES.has("voice-changer-pro")).toBe(true)
   })

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

@@ -102,9 +102,13 @@ describe("per-model prompt length limits", () => {
   })
 
   describe("Suno per-version caps", () => {
-    it("prompt: 500 non-custom; 3000 V4 custom; 5000 V4.5+/V5 custom", () => {
-      expect(getMaxSunoPromptChars("V4", false)).toBe(500)
-      expect(getMaxSunoPromptChars("V5", false)).toBe(500)
+    // Non-custom was 500 until 2026-08-19 — six times under the provider's
+    // documented 3000, and the route truncates rather than rejects, so a
+    // 950-char recast score brief reached Suno cut to exactly 500 mid-word.
+    it("prompt: 3000 non-custom (all models); 3000 V4 custom; 5000 V4.5+/V5 custom", () => {
+      expect(getMaxSunoPromptChars("V4", false)).toBe(3000)
+      expect(getMaxSunoPromptChars("V5", false)).toBe(3000)
+      expect(getMaxSunoPromptChars("V5_5", false)).toBe(3000)
       expect(getMaxSunoPromptChars("V4", true)).toBe(3000)
       expect(getMaxSunoPromptChars("V4_5", true)).toBe(5000)
       expect(getMaxSunoPromptChars("V5", true)).toBe(5000)

package/src/__tests__/seedance2-continuation-ref.test.ts

@@ -11,9 +11,8 @@ import {
  *  job dbf95612 — the original 1.0s tails made every generate-video-pro
  *  continuation segment fail deterministically). Everything this platform
  *  sends as a Seedance-2 video reference cuts SEEDANCE_2_CONTINUATION_REF_SEC
- *  seconds; do NOT "optimize" it back below the floor. The private-plugin
- *  twin constants (nodaro-cloud-plugins chain.ts TAIL_SEC / bridge-math.ts
- *  MIN_REF) are guarded by that repo's r2v-ref-floor.test.ts — keep in sync. */
+ *  seconds; do NOT "optimize" it back below the floor. The plugin repo
+ *  carries twin constants guarded by its own tests — keep the two in sync. */
 describe("seedance-2 continuation-reference floor (do not regress)", () => {
   it("the platform's continuation-ref length clears KIE's r2v minimum", () => {
     expect(SEEDANCE_2_CONTINUATION_REF_SEC).toBeGreaterThanOrEqual(SEEDANCE_2_R2V_MIN_REF_VIDEO_SEC)

package/src/__tests__/video-analysis-catalog-sync.test.ts

@@ -157,7 +157,7 @@ describe("bare video-analysis node-type credit id", () => {
     // 24 and the schedule regenerated ~47% lower at the ceiling bucket, and 300
     // wrote 2064: the V1 hybrid-smart reprice (task A3) moved `smart` to a
     // multi-roll plan (native skeleton + donor rolls, always refined) and
-    // trued up every tier's judge/refine terms from staging measurement).
+    // trued up every tier's judge/refine terms).
     expect(ceiling).toBe(2064)
   })
 

package/src/__tests__/video-analysis-pricing.test.ts

@@ -15,7 +15,7 @@ import {
 
 // The measured-rate constants and the $-derived `videoAnalysisBucketCredits`
 // formula are PRIVATE, in @nodaroai/cloud-plugins
-// (src/plugins/video-analysis/cost.ts) — its tests (the worked-example
+// (in the plugin repo) — its tests (the worked-example
 // bucket-credit values and the cross-check against VIDEO_ANALYSIS_BUCKET_CREDITS
 // below) live in that private package's __tests__/cost.test.ts. This file
 // covers only the NON-monetary duration-bucketing, window-batching, and
@@ -121,7 +121,7 @@ describe("video-analysis-pricing", () => {
   })
 
   // Full drift-detection against the live $-formula lives in the PRIVATE
-  // plugin repo (src/plugins/video-analysis/__tests__/cost.test.ts) — the
+  // plugin repo — the
   // formula moved there in 2026-07 and the app-side test was deleted with it,
   // so nothing in THIS repo can recompute these numbers. This is a lightweight
   // shape check that the precomputed table covers every legal id.

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

@@ -0,0 +1,74 @@
+import { describe, expect, it } from "vitest"
+import {
+  VIDEO_MODE_ALIASES,
+  VIDEO_REF_LIMITS_BY_PROVIDER,
+  resolveVideoModeForInputs,
+  resolveVideoProviderForMode,
+} from "../model-constants.js"
+
+/**
+ * #861 — reference images wired to Grok Imagine 1 without a start frame were
+ * silently dropped: the run resolved to text-to-video, the t2v twin (`grok`)
+ * has no image parameter, and nothing said so. The mode must follow what the
+ * model can CARRY, derived from the catalog's reference caps — not a name.
+ */
+const I2V = "image-to-video"
+const T2V = "text-to-video"
+
+describe("resolveVideoModeForInputs", () => {
+  it("a start frame is image-to-video for every provider", () => {
+    for (const id of ["grok-i2v", "grok", "seedance-2", "kling", "veo3", "wan-i2v", undefined]) {
+      expect(resolveVideoModeForInputs(id, { hasStartFrame: true, hasImageRefs: false })).toBe(I2V)
+      expect(resolveVideoModeForInputs(id, { hasStartFrame: true, hasImageRefs: true })).toBe(I2V)
+    }
+  })
+
+  it("nothing wired is text-to-video", () => {
+    expect(resolveVideoModeForInputs("grok-i2v", { hasStartFrame: false, hasImageRefs: false })).toBe(T2V)
+    expect(resolveVideoModeForInputs(undefined, { hasStartFrame: false, hasImageRefs: true })).toBe(T2V)
+  })
+
+  it("refs alone route Grok Imagine 1 to its i2v twin — the only one that can carry them (#861)", () => {
+    // Whichever member id the node stored (base/i2v/t2v all appear in old workflows).
+    for (const id of ["grok-i2v", "grok"]) {
+      expect(resolveVideoModeForInputs(id, { hasStartFrame: false, hasImageRefs: true })).toBe(I2V)
+    }
+    // The premise, pinned: i2v carries refs, t2v does not.
+    expect(VIDEO_REF_LIMITS_BY_PROVIDER["grok-i2v"]?.images).toBeGreaterThan(0)
+    expect(VIDEO_REF_LIMITS_BY_PROVIDER["grok"]).toBeUndefined()
+  })
+
+  it("single-id models are untouched: the same id serves both modes, so there is nothing to re-route", () => {
+    // seedance-2 / gemini-omni-video / veo forward refs on their t2v path
+    // (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"]) {
+      expect(resolveVideoModeForInputs(id, { hasStartFrame: false, hasImageRefs: true })).toBe(T2V)
+    }
+  })
+
+  it("a split-id model with no ref support on either twin is unaffected (wan, happyhorse)", () => {
+    for (const id of ["wan-i2v", "wan-2.7-i2v", "happyhorse-i2v"]) {
+      expect(resolveVideoModeForInputs(id, { hasStartFrame: false, hasImageRefs: true })).toBe(T2V)
+    }
+  })
+
+  it("every alias group is classified — a new split-id model lands in one of the two pinned outcomes", () => {
+    // Explicit per-group expectations (not a re-derivation of the formula):
+    // grok is the one group whose twins differ on ref support today.
+    const expectedByBase: Record<string, "image-to-video" | "text-to-video"> = {
+      "grok-i2v": I2V,
+      "wan-i2v": T2V,
+      "wan-2.7-i2v": T2V,
+      "happyhorse-i2v": T2V,
+    }
+    expect(VIDEO_MODE_ALIASES.map((g) => g.base).sort()).toEqual(Object.keys(expectedByBase).sort())
+    for (const g of VIDEO_MODE_ALIASES) {
+      const expected = expectedByBase[g.base]!
+      expect(resolveVideoModeForInputs(g.base, { hasStartFrame: false, hasImageRefs: true }), g.base).toBe(expected)
+      // The mode it picks resolves to the twin that can actually run it.
+      if (expected === I2V) expect(resolveVideoProviderForMode(g.base, expected)).toBe(g.i2v)
+    }
+  })
+})

package/src/combine-transitions.ts

@@ -480,3 +480,41 @@ export function resolveXfadeName(id: string): string | null {
   }
   return entry.xfade
 }
+
+/**
+ * Map a `transition` PARAMETER-NODE pick (the @nodaro/prompts creative
+ * catalog — prose-hint transitions for AI video prompts) onto the ffmpeg
+ * xfade vocabulary above. The two vocabularies are deliberately different
+ * (the picker describes shots, this table describes blends); only the
+ * visually-faithful subset maps — everything else falls back to `cut`.
+ *
+ * Consumed by the slideshow node (its transition TYPE comes from a wired
+ * transition parameter node; unwired defaults to cut). Kept here — not in
+ * @nodaro/prompts — because the dependency points prompts → shared, and the
+ * ids are plain strings on both sides.
+ */
+export const PICKER_TO_COMBINE_TRANSITION: Readonly<Record<string, string>> = {
+  "none": "cut",
+  "auto": "dissolve", // an explicitly wired "auto" wants A blend — the classic slideshow default
+  "cross-dissolve": "dissolve",
+  "fade-to-black": "dip-to-black",
+  "fade-to-white": "dip-to-white",
+  "iris": "circle-open",
+  "wipe": "wipe-left",
+  "pixelate-reform": "pixelize",
+  "dissolve-to-mist": "hblur",
+  "match-cut": "cut",
+  "smash-cut": "cut",
+  "freeze-frame-jump": "cut",
+}
+
+/**
+ * Resolve ANY transition string a slideshow may receive — a combine id
+ * (already valid), a picker id (mapped), or anything else (→ cut).
+ */
+export function resolveSlideshowTransition(value: string | undefined | null): string {
+  if (!value) return "cut"
+  if (COMBINE_TRANSITION_IDS.includes(value)) return value
+  return PICKER_TO_COMBINE_TRANSITION[value] ?? "cut"
+}
+

package/src/credit-estimators/video-utils.ts

@@ -155,7 +155,7 @@ export function estimateLoopTrimAddonCredits(
          Math.ceil(frames / VIDEO_UTIL_PRICING.FRAMES_PER_CREDIT)
 }
 
-/** BASE credits (at-cost) for assemble-narrated-video: 3 flat + 1 per 6
+/** BASE credits for assemble-narrated-video: 3 flat + 1 per 6
  *  blocks. 6→4, 24→7, 60→13. Single source of truth shared by the backend
  *  route/creditGuard (`backend/src/providers/video/narrated-block-fit.ts`
  *  re-exports this) and the frontend pre-run estimate

package/src/featured-entities.ts

@@ -1,5 +1,5 @@
 /**
- * Featured entity starter catalog (north-star §6 ③ — the "Featured" tab of each
+ * Featured entity starter catalog (the "Featured" tab of each
  * entity Library).
  *
  * These are app-provided starter presets: a curated visual description per

package/src/i18n/types.ts

@@ -52,8 +52,6 @@ export interface LanguageDefinition {
   readonly shortCode: string
   /** Reading direction. */
   readonly dir: LocaleDirection
-  /** Optional flag emoji for visual recognition. */
-  readonly flag: string
 }
 
 /**
@@ -62,18 +60,18 @@ export interface LanguageDefinition {
  * languages, then RTL languages last.
  */
 export const LANGUAGES: ReadonlyArray<LanguageDefinition> = [
-  { id: "en",    englishName: "English",              nativeName: "English",         shortCode: "EN",  dir: "ltr", flag: "🇬🇧" },
-  { id: "es",    englishName: "Spanish",              nativeName: "Español",         shortCode: "ES",  dir: "ltr", flag: "🇪🇸" },
-  { id: "fr",    englishName: "French",               nativeName: "Français",        shortCode: "FR",  dir: "ltr", flag: "🇫🇷" },
-  { id: "de",    englishName: "German",               nativeName: "Deutsch",         shortCode: "DE",  dir: "ltr", flag: "🇩🇪" },
-  { id: "pt-BR", englishName: "Portuguese (Brazil)",  nativeName: "Português",       shortCode: "PT",  dir: "ltr", flag: "🇧🇷" },
-  { id: "ru",    englishName: "Russian",              nativeName: "Русский",         shortCode: "RU",  dir: "ltr", flag: "🇷🇺" },
-  { id: "hi",    englishName: "Hindi",                nativeName: "हिन्दी",          shortCode: "HI",  dir: "ltr", flag: "🇮🇳" },
-  { id: "ja",    englishName: "Japanese",             nativeName: "日本語",          shortCode: "JA",  dir: "ltr", flag: "🇯🇵" },
-  { id: "ko",    englishName: "Korean",               nativeName: "한국어",          shortCode: "KO",  dir: "ltr", flag: "🇰🇷" },
-  { id: "zh-CN", englishName: "Chinese (Simplified)", nativeName: "简体中文",        shortCode: "ZH",  dir: "ltr", flag: "🇨🇳" },
-  { id: "he",    englishName: "Hebrew",               nativeName: "עברית",           shortCode: "HE",  dir: "rtl", flag: "🇮🇱" },
-  { id: "ar",    englishName: "Arabic",               nativeName: "العربية",         shortCode: "AR",  dir: "rtl", flag: "🇸🇦" },
+  { id: "en",    englishName: "English",              nativeName: "English",         shortCode: "EN",  dir: "ltr" },
+  { id: "es",    englishName: "Spanish",              nativeName: "Español",         shortCode: "ES",  dir: "ltr" },
+  { id: "fr",    englishName: "French",               nativeName: "Français",        shortCode: "FR",  dir: "ltr" },
+  { id: "de",    englishName: "German",               nativeName: "Deutsch",         shortCode: "DE",  dir: "ltr" },
+  { id: "pt-BR", englishName: "Portuguese (Brazil)",  nativeName: "Português",       shortCode: "PT",  dir: "ltr" },
+  { id: "ru",    englishName: "Russian",              nativeName: "Русский",         shortCode: "RU",  dir: "ltr" },
+  { id: "hi",    englishName: "Hindi",                nativeName: "हिन्दी",          shortCode: "HI",  dir: "ltr" },
+  { id: "ja",    englishName: "Japanese",             nativeName: "日本語",          shortCode: "JA",  dir: "ltr" },
+  { id: "ko",    englishName: "Korean",               nativeName: "한국어",          shortCode: "KO",  dir: "ltr" },
+  { id: "zh-CN", englishName: "Chinese (Simplified)", nativeName: "简体中文",        shortCode: "ZH",  dir: "ltr" },
+  { id: "he",    englishName: "Hebrew",               nativeName: "עברית",           shortCode: "HE",  dir: "rtl" },
+  { id: "ar",    englishName: "Arabic",               nativeName: "العربية",         shortCode: "AR",  dir: "rtl" },
 ] as const
 
 export const LOCALE_IDS: ReadonlyArray<LocaleId> = LANGUAGES.map((l) => l.id)

package/src/index.ts

@@ -110,6 +110,7 @@ export {
   VIDEO_MODE_ALIASES,
   VIDEO_GEN_COLLAPSED_T2V_IDS,
   resolveVideoProviderForMode,
+  resolveVideoModeForInputs,
   isSeedance2Provider,
   MINIMAX_H3_PROVIDERS,
   isMinimaxH3Provider,
@@ -281,6 +282,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,
@@ -390,7 +397,6 @@ export {
   TILT_CARRIED_FRACTION,
   isTiltDirection,
   defaultCarriedFraction,
-  buildSurroundFillPrompt,
   type SurroundDirection,
 } from "./surround.js"
 
@@ -756,6 +762,9 @@ export type {
   WorkflowExportObject,
   WorkflowExportCreature,
   WorkflowExportLocation,
+  WorkflowMediaRef,
+  WorkflowPortability,
+  WorkflowImportReport,
 } from "./workflow-export.js"
 export { stripExportContent } from "./workflow-export.js"
 
@@ -854,6 +863,8 @@ export * from "./reduce-strategy-registry.js"
 export {
   COMBINE_TRANSITIONS,
   COMBINE_TRANSITION_IDS,
+  PICKER_TO_COMBINE_TRANSITION,
+  resolveSlideshowTransition,
   COMBINE_TRANSITION_GROUP_ORDER,
   COMBINE_TRANSITION_GROUP_LABELS,
   getCombineTransition,
@@ -880,6 +891,8 @@ export {
   FAN_OUT_EACH_TYPES,
 } from "./producer-types.js"
 
+export { SUNO_TRACK_SOURCE_TYPES } from "./suno-track-sources.js"
+
 export {
   VOICE_CHANGER_MODELS,
   VOICE_CHANGER_MODEL_IDS,
@@ -947,3 +960,6 @@ export * from "./smart-cut-windows.js"
 
 export * from "./entity-asset-types.js"
 export * from "./hint-graph-types.js"
+
+// --- Organizations (second tenancy axis): wire contract only — enums, settings request schemas, error codes ---
+export * from "./organizations/index.js"