@nodaro/shared 2.1.0 → 2.2.0

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

@@ -0,0 +1,128 @@
+import { describe, it, expect } from "vitest"
+import { MODEL_CATALOG } from "../model-catalog.js"
+import {
+  FRAME_MODE_ADAPTIVE_ONLY_ASPECT,
+  MAX_VIDEO_PROMPT_CHARS_BY_PROVIDER,
+  NATIVE_ADAPTIVE_ASPECT,
+  PRICING_DEFAULT_RESOLUTION,
+  PROMPT_HARD_CEILING,
+  SEEDANCE_2_5_REF_LIMITS,
+  SEEDANCE_2_PROVIDERS,
+  VIDEO_DURATION_TIERS,
+  VIDEO_REF_LIMITS_BY_PROVIDER,
+  getMaxVideoPromptChars,
+  isSeedance2Provider,
+  seedance2AudioLimitSec,
+} from "../model-constants.js"
+import { buildVideoCreditModelIdentifier } from "../credit-identifiers.js"
+
+const ID = "seedance-2-5"
+
+/**
+ * Seedance 2.5's shape was established by a live capability probe against
+ * 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.
+ */
+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"])
+  })
+
+  it("runs 4-30s contiguously — 30 is the probed ceiling (31 was rejected)", () => {
+    const durations = MODEL_CATALOG[ID].durations
+    expect(durations?.[0]).toBe(4)
+    expect(durations?.[durations.length - 1]).toBe(30)
+    expect(durations).toHaveLength(27)
+  })
+
+  it("carries the wider 30/10/10 reference caps, NOT the 2.0 family's 9/3/3", () => {
+    expect(VIDEO_REF_LIMITS_BY_PROVIDER[ID]).toEqual({ images: 30, videos: 10, audio: 10 })
+    expect(SEEDANCE_2_5_REF_LIMITS.images).toBeGreaterThan(
+      VIDEO_REF_LIMITS_BY_PROVIDER["seedance-2"]!.images!,
+    )
+  })
+
+  it("joins the Seedance 2 capability family (adaptive aspect, audio, refs)", () => {
+    expect(isSeedance2Provider(ID)).toBe(true)
+    expect(SEEDANCE_2_PROVIDERS.has(ID)).toBe(true)
+    expect(NATIVE_ADAPTIVE_ASPECT[ID]).toBe("adaptive")
+    expect(MODEL_CATALOG[ID].aspectRatios).toContain("adaptive")
+    expect(MODEL_CATALOG[ID].aspectRatios).toContain("21:9")
+  })
+
+  it("forces adaptive aspect in frame mode — the 2.0 SKUs deliberately do NOT", () => {
+    expect(FRAME_MODE_ADAPTIVE_ONLY_ASPECT.has(ID)).toBe(true)
+    for (const p of ["seedance-2", "seedance-2-fast", "seedance-2-mini"]) {
+      expect(FRAME_MODE_ADAPTIVE_ONLY_ASPECT.has(p)).toBe(false)
+    }
+  })
+
+  it("accepts a 30000-char prompt, and the route ceiling is wide enough to pass it through", () => {
+    expect(getMaxVideoPromptChars(ID)).toBe(30000)
+    // The generous route ceiling must never sit BELOW a real per-model cap, or
+    // Zod hard-rejects a prompt the model would have accepted.
+    const caps = Object.values(MAX_VIDEO_PROMPT_CHARS_BY_PROVIDER)
+    expect(PROMPT_HARD_CEILING).toBeGreaterThanOrEqual(Math.max(...caps))
+  })
+
+  it("enforces the documented 30s reference-audio cap", () => {
+    expect(seedance2AudioLimitSec(ID)).toBe(30)
+  })
+})
+
+describe("seedance-2-5 pricing identifiers", () => {
+  const build = (duration?: number, resolution?: string, hasVideoRef?: boolean) =>
+    buildVideoCreditModelIdentifier(ID, duration, undefined, undefined, undefined, resolution, hasVideoRef)
+
+  it("gives every allowed second its OWN tier — no round-up to a coarser rung", () => {
+    // The 2.0 family's 4/8/12/15 ladder would price a 23s render at the 15s
+    // rung; commit_credits only refunds a surplus, so that gap is permanent.
+    expect(VIDEO_DURATION_TIERS[ID]).toHaveLength(27)
+    expect(build(23, "720p")).toBe("seedance-2-5:23s:720p")
+    expect(build(17, "480p")).toBe("seedance-2-5:17s:480p")
+    expect(build(30, "720p")).toBe("seedance-2-5:30s:720p")
+  })
+
+  it("prices an OMITTED resolution at the model's real KIE default (720p), not the cheapest tier", () => {
+    // KIE renders 720p when resolution is absent. Falling back to 480p here
+    // would reserve the cheap tier against an expensive render.
+    expect(PRICING_DEFAULT_RESOLUTION[ID]).toBe("720p")
+    expect(build(8)).toBe("seedance-2-5:8s:720p")
+  })
+
+  it("leaves the 2.0 family's omitted-resolution behaviour untouched", () => {
+    // Adding PRICING_DEFAULT_RESOLUTION must not silently reprice live models.
+    for (const p of ["seedance-2", "seedance-2-fast", "seedance-2-mini"]) {
+      expect(PRICING_DEFAULT_RESOLUTION[p]).toBeUndefined()
+      expect(
+        buildVideoCreditModelIdentifier(p, 8, undefined, undefined, undefined, undefined, false),
+      ).toBe(`${p}:8s:480p`)
+    }
+  })
+
+  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")
+  })
+
+  it("selects the cheaper -ref ladder when a reference video is wired", () => {
+    expect(build(8, "720p", true)).toBe("seedance-2-5:8s:720p-ref")
+    expect(build(8, "480p", true)).toBe("seedance-2-5:8s:480p-ref")
+  })
+
+  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 ref of [false, true]) {
+          const identifier = build(d, res, ref)
+          expect(identifier).toBe(`${ID}:${d}s:${res}${ref ? "-ref" : ""}`)
+          seen.add(identifier)
+        }
+      }
+    }
+    // 27 durations x 2 resolutions x 2 ref-modes, none collapsing onto another.
+    expect(seen.size).toBe(108)
+  })
+})

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

@@ -14,6 +14,7 @@ import {
   VIDEO_ANALYSIS_DURATION_BUCKETS,
   VIDEO_ANALYSIS_MAX_DURATION_SEC,
   buildVideoAnalysisCreditId,
+  VIDEO_AUDIT_BUCKET_CREDITS,
 } from "../video-analysis-pricing.js"
 import { DEFAULT_VIDEO_ANALYSIS_MODEL } from "../llm-models.js"
 
@@ -22,6 +23,18 @@ const catalogRows = Object.values(MODEL_CATALOG)
   .flatMap((m) => (m.pricing ?? []) as ReadonlyArray<{ identifier: string; credits: number }>)
   .filter((r) => r.identifier.startsWith("video-analysis:"))
 
+/**
+ * Every `video-audit*` pricing row declared anywhere in the catalog. NOTE:
+ * no trailing colon in the filter (unlike the `video-analysis:` filter
+ * above) — `video-audit`'s bare base-family id has no colon at all (there's
+ * no per-model segment to be bare "within", unlike video-analysis's bare
+ * per-model ids which still carry `video-analysis:<model>`), so a
+ * colon-anchored filter would silently miss it.
+ */
+const auditCatalogRows = Object.values(MODEL_CATALOG)
+  .flatMap((m) => (m.pricing ?? []) as ReadonlyArray<{ identifier: string; credits: number }>)
+  .filter((r) => r.identifier.startsWith("video-audit"))
+
 describe("model catalog video-analysis pricing", () => {
   it("declares at least one row (guard is actually wired to something)", () => {
     expect(catalogRows.length).toBeGreaterThan(0)
@@ -64,6 +77,56 @@ describe("model catalog video-analysis pricing", () => {
   })
 })
 
+/**
+ * Same guard as above, for `video-audit` ("AI Audit") — a sibling node whose
+ * catalog rows hand-copy `VIDEO_AUDIT_BUCKET_CREDITS`. Mirrors the
+ * video-analysis describe block's structure exactly, adapted for
+ * video-audit's simpler id shape (two FAMILIES — `video-audit` /
+ * `video-audit:auto` — rather than an open set of per-model segments).
+ */
+describe("model catalog video-audit pricing", () => {
+  it("declares at least one row (guard is actually wired to something)", () => {
+    expect(auditCatalogRows.length).toBeGreaterThan(0)
+  })
+
+  it("every bucketed catalog row matches VIDEO_AUDIT_BUCKET_CREDITS exactly", () => {
+    const bucketed = auditCatalogRows.filter((r) => /:\d+s$/.test(r.identifier))
+    expect(bucketed.length).toBeGreaterThan(0)
+    for (const row of bucketed) {
+      expect(
+        row.credits,
+        `catalog "${row.identifier}" = ${row.credits} but the table says ${VIDEO_AUDIT_BUCKET_CREDITS[row.identifier]}`,
+      ).toBe(VIDEO_AUDIT_BUCKET_CREDITS[row.identifier])
+    }
+  })
+
+  it("every bare (no-duration) catalog row equals its 600s ceiling", () => {
+    // A bare id means "duration unknown", which prices at the ceiling.
+    const bare = auditCatalogRows.filter((r) => !/:\d+s$/.test(r.identifier))
+    expect(bare.length).toBe(2) // exactly `video-audit` + `video-audit:auto`
+    for (const row of bare) {
+      const ceiling = VIDEO_AUDIT_BUCKET_CREDITS[`${row.identifier}:${VIDEO_ANALYSIS_MAX_DURATION_SEC}s`]
+      expect(ceiling, `no ceiling row for ${row.identifier}`).toBeDefined()
+      expect(row.credits, `catalog "${row.identifier}" must equal its ${VIDEO_ANALYSIS_MAX_DURATION_SEC}s ceiling`).toBe(ceiling)
+    }
+  })
+
+  it("catalog covers every bucket for both families", () => {
+    const byFamily = new Map<string, Set<number>>()
+    for (const r of auditCatalogRows) {
+      const m = /^(video-audit(?::auto)?):(\d+)s$/.exec(r.identifier)
+      if (!m) continue
+      if (!byFamily.has(m[1]!)) byFamily.set(m[1]!, new Set())
+      byFamily.get(m[1]!)!.add(Number(m[2]))
+    }
+    expect([...byFamily.keys()].sort()).toEqual(["video-audit", "video-audit:auto"])
+    for (const [family, buckets] of byFamily) {
+      expect([...buckets].sort((a, b) => a - b), `${family} bucket coverage`)
+        .toEqual([...VIDEO_ANALYSIS_DURATION_BUCKETS])
+    }
+  })
+})
+
 /**
  * The BARE `video-analysis` node-type id — the one every colon-scoped guard misses.
  *
@@ -90,9 +153,12 @@ describe("bare video-analysis node-type credit id", () => {
     // 279 wrote 739, 283 wrote 346, 284 wrote 350 — `smart` owns the ceiling and
     // gained the continuity pass — 288 wrote 3500 as a x10 of that, 293
     // corrected it to 3496 by RE-DERIVING `smart:600s` from the plugin formula,
-    // and 294 wrote 1868: the smart re-base measured 6 fps equal-or-better than
-    // 24 and the schedule regenerated ~47% lower at the ceiling bucket).
-    expect(ceiling).toBe(1868)
+    // 294 wrote 1868: the smart re-base measured 6 fps equal-or-better than
+    // 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).
+    expect(ceiling).toBe(2064)
   })
 
   it("the bare id still bounds the default tier at the ceiling bucket", () => {

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

@@ -4,6 +4,8 @@ import {
   VIDEO_ANALYSIS_BUCKET_CREDITS,
   pickVideoAnalysisBucket, buildVideoAnalysisCreditId, bucketSecondsFromCreditId,
   videoAnalysisNumWindows,
+  VIDEO_AUDIT_BUCKET_CREDITS,
+  buildVideoAuditCreditId, videoAuditCreditsForBucket, bucketSecondsFromAuditCreditId,
 } from "../video-analysis-pricing.js"
 import {
   VIDEO_ANALYSIS_LLM_MODELS, VIDEO_ANALYSIS_TIERS, VIDEO_ANALYSIS_TIER_ORDER,
@@ -135,3 +137,106 @@ describe("video-analysis-pricing", () => {
     }
   })
 })
+
+// `video-audit` ("AI Audit") is a SEPARATE node from video-analysis, but
+// shares this module's bucket ladder and generator-authoritative table
+// pattern. Its own $-formula and generator live in the private
+// `@nodaroai/cloud-plugins` package exactly like video-analysis's — see
+// `VIDEO_AUDIT_BUCKET_CREDITS`'s doc comment. These values are pasted
+// verbatim from that generator's output; this file only covers the
+// NON-monetary bucket/id-construction logic, same split as above.
+describe("video-audit-pricing", () => {
+  it("buildVideoAuditCreditId: family selection by analysisProvided, same bucket ladder/rounding as buildVideoAnalysisCreditId", () => {
+    expect(buildVideoAuditCreditId({ analysisProvided: true, durationSec: 60 })).toBe("video-audit:60s")
+    expect(buildVideoAuditCreditId({ analysisProvided: false, durationSec: 60 })).toBe("video-audit:auto:60s")
+    expect(buildVideoAuditCreditId({ analysisProvided: true, durationSec: 170 })).toBe("video-audit:180s")
+    expect(buildVideoAuditCreditId({ analysisProvided: false, durationSec: 170 })).toBe("video-audit:auto:180s")
+    expect(buildVideoAuditCreditId({ analysisProvided: true, durationSec: 360 })).toBe("video-audit:360s")
+    expect(buildVideoAuditCreditId({ analysisProvided: true, durationSec: 600 })).toBe("video-audit:600s")
+
+    // Tolerance/boundary edges: 60 stays in the 60s bucket (inclusive upper
+    // bound); 61/63/64 all bump straight to the next bucket (180s) — the
+    // builder has NO grace period of its own (identical cliff behavior to
+    // pickVideoAnalysisBucket / buildVideoAnalysisCreditId; any tolerance
+    // grace is a WORKER re-check concern, private to the plugin, never baked
+    // into this pure id builder).
+    expect(buildVideoAuditCreditId({ analysisProvided: true, durationSec: 60 })).toBe("video-audit:60s")
+    expect(buildVideoAuditCreditId({ analysisProvided: true, durationSec: 61 })).toBe("video-audit:180s")
+    expect(buildVideoAuditCreditId({ analysisProvided: true, durationSec: 63 })).toBe("video-audit:180s")
+    expect(buildVideoAuditCreditId({ analysisProvided: true, durationSec: 64 })).toBe("video-audit:180s")
+    expect(buildVideoAuditCreditId({ analysisProvided: false, durationSec: 61 })).toBe("video-audit:auto:180s")
+
+    // No / invalid duration → 600s ceiling composite, both families — the
+    // ONLY silent-ceiling path, matching buildVideoAnalysisCreditId.
+    expect(buildVideoAuditCreditId({ analysisProvided: true })).toBe("video-audit:600s")
+    expect(buildVideoAuditCreditId({ analysisProvided: false })).toBe("video-audit:auto:600s")
+    expect(buildVideoAuditCreditId({ analysisProvided: true, durationSec: 0 })).toBe("video-audit:600s")
+    expect(buildVideoAuditCreditId({ analysisProvided: true, durationSec: -5 })).toBe("video-audit:600s")
+    expect(buildVideoAuditCreditId({ analysisProvided: true, durationSec: Number.NaN })).toBe("video-audit:600s")
+    // Beyond the ceiling clamps to 600s rather than an out-of-ladder bucket.
+    expect(buildVideoAuditCreditId({ analysisProvided: false, durationSec: 9999 })).toBe("video-audit:auto:600s")
+  })
+
+  it("videoAuditCreditsForBucket: table lookup by resolved bucket + family, snapping a raw duration onto the ladder", () => {
+    expect(videoAuditCreditsForBucket(60, false)).toBe(213)
+    expect(videoAuditCreditsForBucket(60, true)).toBe(393)
+    expect(videoAuditCreditsForBucket(180, false)).toBe(289)
+    expect(videoAuditCreditsForBucket(360, false)).toBe(659)
+    expect(videoAuditCreditsForBucket(600, false)).toBe(1066)
+    expect(videoAuditCreditsForBucket(600, true)).toBe(1912)
+    // Not just exact ladder values — a raw duration snaps up to its bucket.
+    expect(videoAuditCreditsForBucket(70, false)).toBe(VIDEO_AUDIT_BUCKET_CREDITS["video-audit:180s"])
+    expect(videoAuditCreditsForBucket(9999, true)).toBe(VIDEO_AUDIT_BUCKET_CREDITS["video-audit:auto:600s"])
+  })
+
+  it("bucketSecondsFromAuditCreditId: round-trips both families, null on bare ids / video-analysis ids / garbage", () => {
+    for (const bucketSec of VIDEO_ANALYSIS_DURATION_BUCKETS) {
+      expect(bucketSecondsFromAuditCreditId(`video-audit:${bucketSec}s`)).toBe(bucketSec)
+      expect(bucketSecondsFromAuditCreditId(`video-audit:auto:${bucketSec}s`)).toBe(bucketSec)
+      // Round-trips the builder's own output too.
+      expect(bucketSecondsFromAuditCreditId(buildVideoAuditCreditId({ analysisProvided: true, durationSec: bucketSec }))).toBe(bucketSec)
+      expect(bucketSecondsFromAuditCreditId(buildVideoAuditCreditId({ analysisProvided: false, durationSec: bucketSec }))).toBe(bucketSec)
+    }
+    expect(bucketSecondsFromAuditCreditId("video-audit")).toBeNull() // bare base-family id, no bucket
+    expect(bucketSecondsFromAuditCreditId("video-audit:auto")).toBeNull() // bare auto-family id, no bucket
+    // The VA-anchored id space must never be mistaken for an audit id, and vice versa.
+    expect(bucketSecondsFromAuditCreditId("video-analysis:gemini-3-flash:60s")).toBeNull()
+    expect(bucketSecondsFromAuditCreditId("video-analysis:mixed:600s")).toBeNull()
+    expect(bucketSecondsFromCreditId("video-audit:60s")).toBeNull()
+    expect(bucketSecondsFromCreditId("video-audit:auto:60s")).toBeNull()
+    expect(bucketSecondsFromAuditCreditId("garbage")).toBeNull()
+    expect(bucketSecondsFromAuditCreditId("")).toBeNull()
+    expect(bucketSecondsFromAuditCreditId("video-audit:60seconds")).toBeNull()
+    expect(bucketSecondsFromAuditCreditId("video-audit-auto:60s")).toBeNull() // hyphen, not colon — not a legal id
+  })
+
+  it("VIDEO_AUDIT_BUCKET_CREDITS: exactly both families × 4 buckets, positive integers, bare-id ceiling pins", () => {
+    for (const bucketSec of VIDEO_ANALYSIS_DURATION_BUCKETS) {
+      for (const id of [`video-audit:${bucketSec}s`, `video-audit:auto:${bucketSec}s`]) {
+        const credits = VIDEO_AUDIT_BUCKET_CREDITS[id]
+        expect(credits, `missing entry for ${id}`).toBeDefined()
+        expect(Number.isInteger(credits)).toBe(true)
+        expect(credits).toBeGreaterThan(0)
+      }
+    }
+    // Exactly 2 families × 4 buckets — no stray keys, no bare-id keys (bare
+    // ids live only in model-catalog.ts's pricing rows, derived from the
+    // 600s bucket here, same convention as VIDEO_ANALYSIS_BUCKET_CREDITS).
+    expect(Object.keys(VIDEO_AUDIT_BUCKET_CREDITS)).toHaveLength(8)
+    // Bare-id values quoted in the task/catalog must equal each family's 600s ceiling.
+    expect(VIDEO_AUDIT_BUCKET_CREDITS["video-audit:600s"]).toBe(1066)
+    expect(VIDEO_AUDIT_BUCKET_CREDITS["video-audit:auto:600s"]).toBe(1912)
+  })
+
+  it("auto family = base family + the gemini-3-flash (legacy fast tier) row at the same bucket, exactly — single-source, never hand-added", () => {
+    // Single-source assertion: reads the fast-tier row straight out of
+    // VIDEO_ANALYSIS_BUCKET_CREDITS rather than re-hardcoding 180/185/514/846
+    // here, so this test can't silently drift from that table either.
+    for (const bucketSec of VIDEO_ANALYSIS_DURATION_BUCKETS) {
+      const base = VIDEO_AUDIT_BUCKET_CREDITS[`video-audit:${bucketSec}s`]!
+      const auto = VIDEO_AUDIT_BUCKET_CREDITS[`video-audit:auto:${bucketSec}s`]!
+      const fastRow = VIDEO_ANALYSIS_BUCKET_CREDITS[`video-analysis:gemini-3-flash:${bucketSec}s`]!
+      expect(auto - base, `auto-base mismatch at ${bucketSec}s`).toBe(fastRow)
+    }
+  })
+})

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

@@ -353,6 +353,19 @@ describe("misc", () => {
     expect(isOversizedScene(0, 8)).toBe(false)
     expect(isOversizedScene(0, 8.5)).toBe(true)
   })
+
+  it("does not flag an exactly-8s scene whose float subtraction overshoots", () => {
+    // Real job bdc9c8eb: 12.67 → 20.67 computes as 8.000000000000002.
+    expect(20.67 - 12.67).toBeGreaterThan(8) // the hazard this guards
+    expect(isOversizedScene(12.67, 20.67)).toBe(false)
+    // Same hazard at other offsets — none of these are genuinely over the cap.
+    expect(isOversizedScene(4.67, 12.67)).toBe(false)
+    expect(isOversizedScene(0.1, 8.1)).toBe(false)
+  })
+
+  it("still flags a real overshoot far smaller than a boundary step", () => {
+    expect(isOversizedScene(0, 8.01)).toBe(true)
+  })
   it("aspectRatioFromDims snaps to nearest standard, else reduces", () => {
     expect(aspectRatioFromDims(1920, 1080)).toBe("16:9")
     expect(aspectRatioFromDims(1080, 1920)).toBe("9:16")

package/src/credit-identifiers.ts

@@ -15,9 +15,13 @@ import {
   RESOLUTION_DURATION_PRICING,
   VEO_RESOLUTION_TIERED_PROVIDERS,
   VIDEO_DURATION_TIERS,
+  PRICING_DEFAULT_DURATION_SEC,
+  PRICING_DEFAULT_RESOLUTION,
   MOTION_DURATION_TIERS,
   T2I_TO_I2I_VARIANT,
   isVeoProvider,
+  isMinimaxH3Provider,
+  normalizeMinimaxH3Resolution,
   getVideoAudioCapability,
 } from "./model-constants.js"
 import { isFlux2Model } from "./flux2-pricing.js"
@@ -219,8 +223,12 @@ export function buildVideoCreditModelIdentifier(
     return effectiveProvider
   }
 
-  const parsed = typeof duration === "string" ? parseInt(duration, 10) : (duration ?? 5)
-  const durationSec = Number.isNaN(parsed) ? 5 : parsed
+  // A named-provider request with NO duration renders the model's own default
+  // (kie/models.ts extraParams), so price that default — not the global 5s —
+  // for providers whose per-second tiers wouldn't snap 5 up to it (minimax-h3).
+  const durationFallback = PRICING_DEFAULT_DURATION_SEC[effectiveProvider] ?? 5
+  const parsed = typeof duration === "string" ? parseInt(duration, 10) : (duration ?? durationFallback)
+  const durationSec = Number.isNaN(parsed) ? durationFallback : parsed
   const tiers = VIDEO_DURATION_TIERS[effectiveProvider]
   if (!tiers) return effectiveProvider
 
@@ -253,7 +261,13 @@ export function buildVideoCreditModelIdentifier(
     // maps to its top priced tier instead of emitting an unpriced composite
     // (which the hard-fail credit guard would 503 on at runtime).
     const supported = MODEL_CATALOG[effectiveProvider]?.resolutions ?? ["480p", "720p", "1080p"]
-    const want = resolution === "4k" ? "4k" : resolution === "1080p" ? "1080p" : resolution === "720p" ? "720p" : "480p"
+    // An OMITTED resolution renders the model's KIE-side default, so price that
+    // default rather than the cheapest tier — otherwise an intent-less request
+    // reserves 480p against a 720p render and commit_credits (refund-only) can
+    // never collect the delta. Providers without an entry keep the historical
+    // 480p fallback, so this cannot reprice anything already live.
+    const requested = resolution ?? PRICING_DEFAULT_RESOLUTION[effectiveProvider]
+    const want = requested === "4k" ? "4k" : requested === "1080p" ? "1080p" : requested === "720p" ? "720p" : "480p"
     // Unsupported (e.g. a stale 1080p on seedance-2-mini) clamps to the model's
     // top priced tier so the emitted composite is always seeded.
     const res = supported.includes(want) ? want : (supported[supported.length - 1] ?? "480p")
@@ -271,6 +285,16 @@ export function buildVideoCreditModelIdentifier(
     identifier += `:${res}`
   }
 
+  // MiniMax Hailuo 3 (768P lever, 2026-08-03): bare duration composites stay
+  // the 2K (default) rate — byte-identical to the pre-lever seeded rows, so
+  // existing workflows and admin overrides keep their ids — and only a
+  // verified 768P selection appends ":768p". normalizeMinimaxH3Resolution
+  // collapses anything else to 2K, matching what KIE renders for an
+  // omitted/unknown value, so billing can never undercut the render.
+  if (isMinimaxH3Provider(effectiveProvider) && normalizeMinimaxH3Resolution(resolution) === "768P") {
+    identifier += ":768p"
+  }
+
   return identifier
 }
 

package/src/film-pricing.ts

@@ -56,6 +56,7 @@ export const VIDEO_CLIP_CREDITS: Record<string, VideoClipCost> = {
   "seedance-2": { credits: 50, clipSeconds: 8 }, // seedance-2:8s:720p-ref
   "seedance-2-fast": { credits: 40, clipSeconds: 8 }, // seedance-2-fast:8s:720p-ref
   "seedance-2-mini": { credits: 25, clipSeconds: 8 }, // seedance-2-mini:8s:720p-ref
+  "seedance-2-5": { credits: 76, clipSeconds: 8 }, // seedance-2-5:8s:720p-ref
   "veo3": { credits: 79, clipSeconds: 8 }, // flat per generation (VEO 3.1 Quality)
   "veo3.1": { credits: 19, clipSeconds: 6 }, // veo3.1 @ 720p
   "veo3_lite": { credits: 10, clipSeconds: 6 }, // veo3_lite @ 720p

package/src/index.ts

@@ -97,10 +97,12 @@ export {
   GUIDANCE_SCALE_SUPPORT,
   SEEDANCE_2_PROVIDERS,
   SEEDANCE_2_REF_LIMITS,
+  SEEDANCE_2_5_REF_LIMITS,
   SEEDANCE_2_EXTEND_STITCH,
   SEEDANCE_2_R2V_MIN_REF_VIDEO_SEC,
   SEEDANCE_2_CONTINUATION_REF_SEC,
   NATIVE_ADAPTIVE_ASPECT,
+  FRAME_MODE_ADAPTIVE_ONLY_ASPECT,
   VIDEO_REF_LIMITS_BY_PROVIDER,
   VIDEO_PROVIDERS_REQUIRING_IMAGE,
   videoProviderRequiresImage,
@@ -108,8 +110,25 @@ export {
   VIDEO_GEN_COLLAPSED_T2V_IDS,
   resolveVideoProviderForMode,
   isSeedance2Provider,
+  MINIMAX_H3_PROVIDERS,
+  isMinimaxH3Provider,
+  MINIMAX_H3_DEFAULT_RESOLUTION,
+  normalizeMinimaxH3Resolution,
+  VIDEO_PROVIDERS_WITHOUT_DISPATCH,
+  GVP_DEFAULT_PROVIDER,
   GVP_SUPPORTED_PROVIDERS,
   isGvpSupportedProvider,
+  GVP_EXTEND_PROVIDERS,
+  supportsExtendRender,
+  GVP_END_FRAME_PROVIDERS,
+  supportsEndAnchor,
+  GVP_ANCHOR_CHOICES,
+  resolveGvpAnchorWire,
+  segmentDurationsFor,
+  minSegmentSecFor,
+  maxSegmentSecFor,
+  hasContiguousSegmentDurations,
+  maxSegmentsFor,
   defaultVideoAspectRatio,
   CHARACTER_MOTION_PROVIDERS,
   LOCATION_ATMOSPHERE_PROVIDERS,
@@ -126,6 +145,8 @@ export {
   DEFAULT_VIDEO_PROVIDER,
   DEFAULT_VIDEO_DURATION_SEC,
   applyDefaultVideoSelection,
+  PRICING_DEFAULT_DURATION_SEC,
+  PRICING_DEFAULT_RESOLUTION,
 } from "./model-constants.js"
 
 export {
@@ -177,6 +198,8 @@ export type {
   VideoModelCapabilities,
   VideoAudioMode,
   VideoAudioCapability,
+  GvpAnchorChoice,
+  GvpAnchorWireMode,
 } from "./model-constants.js"
 
 
@@ -895,6 +918,8 @@ export * from "./reference-roles.js"
 export * from "./video-analysis.js"
 
 // --- Video-analysis pricing (duration buckets + structural credit formula) ---
+// Also hosts video-audit's sibling pricing (VIDEO_AUDIT_BUCKET_CREDITS +
+// buildVideoAuditCreditId / videoAuditCreditsForBucket / bucketSecondsFromAuditCreditId).
 export * from "./video-analysis-pricing.js"
 
 // --- Smart-cut best-pair search windows (shared bound + clamp) ---

package/src/llm-models.ts

@@ -712,14 +712,17 @@ export const VIDEO_ANALYSIS_MIXED_TIERS = ["mixed", "mixed-fast", "smart"] as co
 export type VideoAnalysisMixedTier = (typeof VIDEO_ANALYSIS_MIXED_TIERS)[number]
 /**
  * `smart` is an ENGINE-PLAN sentinel like the mixed tiers — it names a plan, not a
- * model — but it is the opposite kind of plan, and the distinction is the whole
+ * model — but it is a different SHAPE of plan, and the distinction is the whole
  * reason it exists as a separate tier rather than a repricing of the others.
  *
  * The economy tiers (`fast`, `pro`, `mixed`, `mixed-fast`) run several passes on
- * the cheaper proxied transport and vote. That transport is 3-4x cheaper per token
- * and additionally does no deep reasoning, which is why they cost single-digit
- * credits — and also why they are less accurate. `smart` runs ONE pass on the
- * native transport with everything turned up, which is where the accuracy is.
+ * the cheaper proxied transport and vote. That transport is cheaper per token and
+ * additionally does no deep reasoning, which is why they cost less — and also why
+ * they are less accurate. `smart` is a HYBRID plan (2026-08-03 re-plan): one
+ * native-transport skeleton pass with everything turned up, blended with several
+ * economy-transport donor rolls, and the merged result is always refined —
+ * `selectionMode` (the `choose`/`combine` toggle the other tiers expose) does not
+ * apply to `smart`; it always applies the equivalent of `combine`.
  *
  * As with the mixed sentinels, what the plan does internally is deliberately not
  * published here; only the wire vocabulary is contract.