@nodaro/prompts 1.21.0 → 1.25.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nodaro/prompts",
-  "version": "1.21.0",
+  "version": "1.25.0",
   "description": "Nodaro's prompt-engineering layer — person/picker catalogs with prompt hints, identity-lock clauses, entity prompt builders, brand presets, and prompt/reference assembly shared by the Nodaro platform and SDK.",
   "type": "module",
   "license": "FSL-1.1-Apache-2.0",
@@ -20,7 +20,7 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@nodaro/shared": "^3.11.0"
+    "@nodaro/shared": "^3.12.0"
   },
   "devDependencies": {
     "tsup": "^8.5.0",

package/src/__tests__/assemble-video-input.test.ts

@@ -7,7 +7,7 @@ import {
   renderDirectionHints,
 } from "../direction-registry.js"
 import { getStylePromptHint, getStyleTerm } from "../style.js"
-import { getTransitionPromptHint, getTransitionTerm } from "../transitions.js"
+import { renderTransitionBases } from "../transitions.js"
 import { getCameraMotionPromptHint, getCameraMotionTerm } from "../camera-motions.js"
 import { getFramingPromptHint } from "../framing.js"
 import { getLightingPromptHint } from "../lighting.js"
@@ -78,28 +78,36 @@ describe("composeVideoPromptText — the verbosity policy", () => {
   })
 
   it("renders a MOTION dimension as its compact term, not its full hint", () => {
-    const out = composeVideoPromptText("a knight", { transition: TRANSITION })
-    expect(out).toBe(`a knight. ${getTransitionTerm(TRANSITION)}`)
-    expect(out).not.toContain(getTransitionPromptHint(TRANSITION))
+    const out = composeVideoPromptText("a knight", { cameraMotion: CAMERA_MOTION })
+    expect(out).toBe(`a knight. ${getCameraMotionTerm(CAMERA_MOTION)}`)
+    expect(out).not.toContain(getCameraMotionPromptHint(CAMERA_MOTION))
+  })
+
+  it("renders a TRANSITION as `term (hint)` in every mode — the bare term did not steer the model", () => {
+    const expected = `a knight. ${renderTransitionBases([TRANSITION])[0]}`
+    expect(composeVideoPromptText("a knight", { transition: TRANSITION })).toBe(expected)
+    for (const hintMode of ["full", "compact"] as const) {
+      expect(composeVideoPromptText("a knight", { transition: TRANSITION }, undefined, { hintMode })).toBe(expected)
+    }
   })
 
   it("applies both halves of the split policy in ONE fold", () => {
     const out = composeVideoPromptText("a knight", {
       style: STYLE,
-      transition: TRANSITION,
+      cameraMotion: CAMERA_MOTION,
     })
     expect(out).toContain(getStylePromptHint(STYLE))
-    expect(out).toContain(getTransitionTerm(TRANSITION))
-    expect(out).not.toContain(getTransitionPromptHint(TRANSITION))
+    expect(out).toContain(getCameraMotionTerm(CAMERA_MOTION))
+    expect(out).not.toContain(getCameraMotionPromptHint(CAMERA_MOTION))
   })
 
   it("honors a whole-fold `hintMode` override in both directions", () => {
     // "full" promotes the motion family to its full clause…
     expect(
-      composeVideoPromptText("a knight", { transition: TRANSITION }, undefined, {
+      composeVideoPromptText("a knight", { cameraMotion: CAMERA_MOTION }, undefined, {
         hintMode: "full",
       }),
-    ).toBe(`a knight. ${getTransitionPromptHint(TRANSITION)}`)
+    ).toBe(`a knight. ${getCameraMotionPromptHint(CAMERA_MOTION)}`)
     // …and "compact" demotes the look family to its term. Verbosity does not
     // move a clause: the look term still reads in the section.
     expect(
@@ -124,7 +132,7 @@ describe("composeVideoPromptText — what stays in the body", () => {
       transition: TRANSITION,
     })
     expect(out).toBe(
-      `a knight. ${getCameraMotionTerm(CAMERA_MOTION)}. ${getTransitionTerm(TRANSITION)}`,
+      `a knight. ${getCameraMotionTerm(CAMERA_MOTION)}. ${renderTransitionBases([TRANSITION])[0]}`,
     )
     expect(out).not.toContain("[style]")
   })
@@ -248,13 +256,13 @@ describe("composeVideoPromptText — tolerance", () => {
 describe("composeVideoPromptText — an empty or absent body", () => {
   it("returns the hints alone for an empty prompt (never a leading '. ')", () => {
     expect(composeVideoPromptText("", { transition: TRANSITION })).toBe(
-      getTransitionTerm(TRANSITION),
+      renderTransitionBases([TRANSITION])[0],
     )
   })
 
   it("returns the hints alone for an ABSENT prompt", () => {
     expect(composeVideoPromptText(undefined, { transition: TRANSITION })).toBe(
-      getTransitionTerm(TRANSITION),
+      renderTransitionBases([TRANSITION])[0],
     )
   })
 

package/src/__tests__/camera-motion-approved.test.ts

@@ -0,0 +1,46 @@
+/**
+ * Every Camera Motion injection was approved on screen (the Camera Motion Lab,
+ * 2026-08/09). A cinematic label alone did not drive the model — "camera
+ * trucks to the left" barely moved the image and "orbits to the left" went a
+ * random way — so each option carries a description of what the camera
+ * physically does, tested take by take on a base frame built for its family.
+ *
+ * The approved wording is pinned here with the clip that approved it. Changing
+ * an injection means re-running it on its base frame first; a new option needs
+ * its own approved take before it joins this list.
+ */
+import { readFileSync } from "node:fs"
+import { describe, expect, it } from "vitest"
+import { CAMERA_MOTIONS } from "../camera-motions"
+
+interface ApprovedInjection {
+  readonly id: string
+  readonly approvedClip: string
+  readonly injection: string
+}
+
+const fixture = JSON.parse(
+  readFileSync(new URL("./fixtures/camera-motion-approved.json", import.meta.url), "utf8"),
+) as { readonly unapproved: readonly string[]; readonly approved: readonly ApprovedInjection[] }
+
+const byId = new Map(CAMERA_MOTIONS.map((motion) => [motion.id, motion]))
+
+describe("Camera Motion injections", () => {
+  it.each(fixture.approved.map((row) => [row.id, row] as const))("%s sends its lab-approved wording", (id, row) => {
+    expect(byId.get(id)?.promptHint).toBe(row.injection)
+  })
+
+  it("has an approved take for every option but the ones never built", () => {
+    const approved = new Set(fixture.approved.map((row) => row.id))
+    const unaccounted = CAMERA_MOTIONS.map((motion) => motion.id).filter((id) => !approved.has(id))
+    expect(unaccounted.sort()).toEqual([...fixture.unapproved].sort())
+  })
+
+  // An edit-type transition's real-world trigger gets drawn into the scene:
+  // "finger tap" put a finger on screen, and the compact term is sent as-is.
+  it("never names a transition's physical trigger in the compact term", () => {
+    for (const id of ["screen-tap", "phone-flip"]) {
+      expect(byId.get(id)?.term ?? "").not.toMatch(/finger|phone|hand|tap|click/i)
+    }
+  })
+})

package/src/__tests__/camera-motions-from-connections.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest"
-import { composeCameraMotionHintFromConnections } from "../camera-motions.js"
+import { CAMERA_MOTIONS, composeCameraMotionHintFromConnections } from "../camera-motions.js"
 
 describe("composeCameraMotionHintFromConnections", () => {
   it("returns empty string for unknown motion", () => {
@@ -64,7 +64,8 @@ describe("composeCameraMotionHintFromConnections", () => {
       ["wide shot"],
       ["close-up"],
     )
-    expect(out).toContain("static")
+    // The static hint itself, whatever its approved wording.
+    expect(out).toContain(CAMERA_MOTIONS.find((motion) => motion.id === "static")!.promptHint)
     expect(out).toContain("beginning with wide shot")
     expect(out).toContain("ending with close-up")
   })

package/src/__tests__/catalog-packs.test.ts

@@ -40,6 +40,19 @@ describe("composePickerCatalogs — pure", () => {
     expect(out[0].options!.map((o: PickerOption) => o.id)).toEqual(["forest", "beach", "shul"])
   })
 
+  it("denies auxiliary dimensions on single catalogs and replaces a removed default", () => {
+    const hybrid: PickerCatalog = { ...base[0], defaultValue: "beach", dimensions: [
+      { field: "speed", label: "Speed", options: [{ id: "fast", label: "Fast", term: "fast", promptHint: "fast" }] },
+    ] }
+    const [out] = composePickerCatalogs([hybrid], [{ id: "curation", catalogId: "setting", mode: "deny", denyIds: ["beach", "fast"] }])
+    expect(out.options?.map((o) => o.id)).toEqual(["forest"])
+    expect(out.dimensions?.[0].options).toEqual([])
+    expect(out.defaultValue).toBe("forest")
+    expect(hybrid.dimensions?.[0].options).toHaveLength(1)
+    const [empty] = composePickerCatalogs([hybrid], [{ id: "empty", catalogId: "setting", mode: "deny", denyIds: ["forest", "beach", "fast"] }])
+    expect(empty.defaultValue).toBeUndefined()
+  })
+
   it("replace swaps the catalog wholesale for its catalogId", () => {
     const vendored: PickerCatalogInput = { nodeType: "setting", label: "Setting", catalogId: "setting", kind: "single",
       valueField: "setting", options: [{ id: "forest", label: "Forest", promptHint: "in a forest", term: "forest" }] }

package/src/__tests__/character-fx-timing-catalogs.test.ts

@@ -86,8 +86,9 @@ describe("character-fx timing catalogs", () => {
     // The one constraint that matters most: these scales must never be unified
     // with the transition ones. Position and duration are worded differently
     // on purpose, so pointing character-fx at the transition rows fails here.
-    // Intensity is deliberately NOT compared: its three clauses happen to be
-    // identical today, and that is a coincidence, not a shared definition.
+    // Intensity is deliberately NOT compared: its clauses happen to mostly
+    // match, and that is a coincidence, not a shared definition (transitions'
+    // "natural" already reads differently since 2026-09-24).
     expect(CHARACTER_FX_POSITIONS.map((o) => o.promptHint)).not.toEqual(
       TRANSITION_POSITIONS.map((o) => o.promptHint),
     )

package/src/__tests__/factory-presets.test.ts

@@ -5,7 +5,7 @@ import { COMPOSER_PLAN_MAP, COMPOSER_PLAN_FIELDS } from "@nodaro/shared"
 import { STYLE_IDS } from "../index.js"
 import { joinPromptParts } from "../resolve-prompt.js"
 import { nodeSupportsPromptAffixes } from "../node-prompt-fields.js"
-import { IMAGE_GEN_PROVIDERS, MODIFY_IMAGE_PROVIDERS, VIDEO_GEN_PROVIDERS, VIDEO_TO_VIDEO_PROVIDERS, MUSIC_PROVIDERS, SUNO_MODELS, TTS_PROVIDERS, TEXT_TO_AUDIO_PROVIDERS, ALL_CAPTION_STYLES, COMBINE_TRANSITION_IDS, AUDIO_CROSSFADE_CURVE_IDS, aspectRatioOptionsByKind, durationsByMode, IMAGE_PROMPT_MAX, MODEL_CATALOG, NATIVE_NEGATIVE_VIDEO_PROVIDERS } from "@nodaro/shared"
+import { IMAGE_GEN_PROVIDERS, MODIFY_IMAGE_PROVIDERS, VIDEO_GEN_PROVIDERS, VIDEO_TO_VIDEO_PROVIDERS, MUSIC_PROVIDERS, SUNO_MODELS, TTS_PROVIDERS, TEXT_TO_AUDIO_PROVIDERS, ALL_CAPTION_STYLES, COMBINE_TRANSITION_IDS, AUDIO_CROSSFADE_CURVE_IDS, aspectRatioOptionsByKind, durationsByMode, IMAGE_PROMPT_MAX, MODEL_CATALOG, NATIVE_NEGATIVE_VIDEO_PROVIDERS, VIDEO_DURATION_AUTO, supportsAutoVideoDuration } from "@nodaro/shared"
 
 /**
  * The text a preset ACTUALLY sends: a preset may ship its doctrine as pre/post
@@ -327,6 +327,8 @@ describe("generate-video factory preset data validity", () => {
     new Set<number>([
       ...(durationsByMode("t2v")[provider] ?? []),
       ...(durationsByMode("i2v")[provider] ?? []),
+      // Auto (-1) is a catalog capability, not a member of the seconds list.
+      ...(supportsAutoVideoDuration(provider) ? [VIDEO_DURATION_AUTO] : []),
     ])
 
   it("uses a known video provider when set", () => {
@@ -382,8 +384,10 @@ describe("generate-video factory preset data validity", () => {
         NATIVE_NEGATIVE_VIDEO_PROVIDERS.has(provider),
         `${p.id}: missing negativePrompt on a native-negative provider`,
       ).toBe(false)
+      // The ASSEMBLED prompt — an affix-only preset (the user's own sentence is
+      // the whole prompt) carries its constraint tail in the post text.
       expect(
-        (p.data.prompt as string) ?? "",
+        effectivePrompt(p.data),
         `${p.id}: omits negativePrompt but carries no in-prompt constraint tail`,
       ).toContain("subtitle-free")
     }
@@ -392,7 +396,7 @@ describe("generate-video factory preset data validity", () => {
   it("non-style-pinned generate-video prompts are substantive", () => {
     for (const p of presets) {
       if (p.data.style !== undefined) continue
-      const prompt = (p.data.prompt as string | undefined) ?? ""
+      const prompt = effectivePrompt(p.data)
       expect(prompt.trim().length, `${p.id}: prompt too thin (${prompt.length} chars)`).toBeGreaterThanOrEqual(40)
     }
   })
@@ -1099,3 +1103,24 @@ describe("factory-presets split integrity", () => {
     }
   })
 })
+
+describe("generate-video/edit-video — the Seedance 2.5 edit shape, up front", () => {
+  const preset = getFactoryPresets("generate-video").find((p) => p.id === "generate-video/edit-video")!
+
+  it("ships exactly what edit mode requires: Adaptive ratio + Auto duration on seedance-2-5", () => {
+    expect(preset.data.provider).toBe("seedance-2-5")
+    expect(preset.data.aspectRatio).toBe("adaptive")
+    expect(preset.data.duration).toBe(VIDEO_DURATION_AUTO)
+    expect(supportsAutoVideoDuration(preset.data.provider as string)).toBe(true)
+  })
+
+  it("owns only the pre & post text — the user's sentence is the prompt", () => {
+    expect(preset.data.prompt).toBeUndefined()
+    expect(preset.data.promptPrefix).toBe("edit {video:1} as follows:\n")
+    // The instruction lands on its own line, straight after the prefix.
+    expect(effectivePrompt({ ...preset.data, prompt: "make it black and white" })).toMatch(
+      /^edit \{video:1\} as follows:\nmake it black and white/,
+    )
+  })
+})
+