@nodaro/prompts 1.21.0 → 1.23.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nodaro/prompts",
-  "version": "1.21.0",
+  "version": "1.23.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__/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__/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/,
+    )
+  })
+})
+

package/src/__tests__/fixtures/parameter-hint-golden.json

@@ -2970,19 +2970,19 @@
     },
     {
       "key": "transition/timing",
-      "note": "transition with position + duration + intensity, no ctx",
+      "note": "transition with position + duration + intensity, no ctx (a non-instant row, so the duration clause is emitted)",
       "node": {
         "id": "n1",
         "type": "transition",
         "data": {
-          "transition": "none",
+          "transition": "cross-dissolve",
           "position": "middle",
           "duration": "short",
           "intensity": "dynamic"
         }
       },
       "ctx": null,
-      "expected": "no transition, hard cut, instantaneous switch from first shot to second shot, the transition occurs in the middle of the clip, lasting approximately 1 second, with dynamic energy and assertive flourish"
+      "expected": "smooth cross-dissolve transition where the first shot gradually fades out as the second shot fades in, the transition occurs in the middle of the clip, lasting approximately 1 second, with dynamic energy and assertive flourish"
     },
     {
       "key": "transition/timing-auto",
@@ -3000,6 +3000,22 @@
       "ctx": null,
       "expected": "no transition, hard cut, instantaneous switch from first shot to second shot"
     },
+    {
+      "key": "transition/timing-instant",
+      "note": "an INSTANT transition (a cut) with position + duration + intensity — the duration clause is dropped",
+      "node": {
+        "id": "n1",
+        "type": "transition",
+        "data": {
+          "transition": "none",
+          "position": "middle",
+          "duration": "short",
+          "intensity": "dynamic"
+        }
+      },
+      "ctx": null,
+      "expected": "no transition, hard cut, instantaneous switch from first shot to second shot, the transition occurs in the middle of the clip, with dynamic energy and assertive flourish"
+    },
     {
       "key": "transition/with-ctx",
       "note": "transition composing startState + endState clauses",

package/src/__tests__/node-prompt-fields.test.ts

@@ -16,10 +16,10 @@ describe("nodeSupportsPromptAffixes", () => {
     expect(nodeSupportsPromptAffixes("not-a-node")).toBe(false)
     expect(nodeSupportsPromptAffixes(undefined)).toBe(false)
   })
-  it("PROMPT_AFFIX_NODE_TYPES is exactly the registry minus opt-outs (40 types)", () => {
+  it("PROMPT_AFFIX_NODE_TYPES is exactly the registry minus opt-outs (41 types)", () => {
     const expected = Object.entries(NODE_PROMPT_FIELDS).filter(([, s]) => s.affixes !== false).map(([t]) => t)
     expect([...PROMPT_AFFIX_NODE_TYPES].sort()).toEqual(expected.sort())
-    expect(PROMPT_AFFIX_NODE_TYPES.size).toBe(40)
+    expect(PROMPT_AFFIX_NODE_TYPES.size).toBe(41)
   })
   it("getPromptFields still resolves", () => expect(getPromptFields("generate-image")?.prompt).toBe("prompt"))
 })

package/src/__tests__/transitions-instant.test.ts

@@ -0,0 +1,112 @@
+import { describe, expect, it } from "vitest"
+import {
+  TRANSITIONS,
+  TRANSITION_DURATIONS,
+  composeTransitionHintFromConnections,
+  isInstantTransition,
+} from "../transitions.js"
+import { getPickerCatalog } from "../picker-catalogs.js"
+
+/**
+ * F5 (transition QA, 2026-09-22): a duration clause on a cut ("match cut, …,
+ * lasting approximately 1 second") made the video model render a 1.75 s
+ * dissolve. Rows whose mechanism IS a cut carry `instant: true`, and the
+ * composer drops the duration lever for them.
+ */
+const INSTANT_IDS = [
+  "none",
+  "snap-to-black",
+  "match-cut",
+  "smash-cut",
+  "seamless-match",
+  "jump-cut",
+  "jump-match",
+  "action-relay",
+]
+
+const DURATION_HINTS = TRANSITION_DURATIONS.map((d) => d.promptHint).filter((h) => h.length > 0)
+
+describe("instant transitions — the catalog marker", () => {
+  it("marks exactly the cut rows", () => {
+    expect(TRANSITIONS.filter((t) => t.instant).map((t) => t.id).sort()).toEqual([...INSTANT_IDS].sort())
+  })
+
+  it("isInstantTransition answers per id, and false for unknown / auto / empty", () => {
+    for (const id of INSTANT_IDS) expect(isInstantTransition(id)).toBe(true)
+    expect(isInstantTransition("cross-dissolve")).toBe(false)
+    expect(isInstantTransition("whip-pan")).toBe(false)
+    expect(isInstantTransition("freeze-frame-jump")).toBe(false)
+    expect(isInstantTransition("auto")).toBe(false)
+    expect(isInstantTransition("nonexistent")).toBe(false)
+    expect(isInstantTransition("")).toBe(false)
+    expect(isInstantTransition(undefined)).toBe(false)
+    expect(isInstantTransition(null)).toBe(false)
+    expect(isInstantTransition([])).toBe(false)
+  })
+
+  it("a multi-pick is instant only when every id is", () => {
+    expect(isInstantTransition(["match-cut", "smash-cut"])).toBe(true)
+    expect(isInstantTransition(["match-cut", "cross-dissolve"])).toBe(false)
+  })
+})
+
+describe("instant transitions — the composer drops the duration lever", () => {
+  for (const mode of ["full", "compact"] as const) {
+    it(`${mode}: no duration clause on any instant row, for every duration`, () => {
+      for (const id of INSTANT_IDS) {
+        for (const d of TRANSITION_DURATIONS) {
+          const r = composeTransitionHintFromConnections(id, [], [], { duration: d.id }, mode)
+          for (const hint of DURATION_HINTS) expect(r).not.toContain(hint)
+        }
+      }
+    })
+
+    it(`${mode}: position and intensity still apply to a cut`, () => {
+      const r = composeTransitionHintFromConnections(
+        "match-cut", [], [], { position: "middle", duration: "short", intensity: "natural" }, mode,
+      )
+      expect(r).toContain("the transition occurs in the middle of the clip")
+      expect(r).toContain("with natural unhurried timing")
+      expect(r).not.toContain("lasting approximately")
+    })
+  }
+
+  it("compact match cut reads term + position + intensity only", () => {
+    expect(
+      composeTransitionHintFromConnections(
+        "match-cut", [], [], { position: "middle", duration: "short", intensity: "natural" }, "compact",
+      ),
+    ).toBe("match cut, the transition occurs in the middle of the clip, with natural unhurried timing")
+  })
+
+  it("a non-instant row keeps its duration", () => {
+    const r = composeTransitionHintFromConnections("cross-dissolve", [], [], { duration: "short" })
+    expect(r).toContain("lasting approximately 1 second")
+  })
+
+  it("a mixed pick keeps its duration — the non-cut still has a length", () => {
+    const r = composeTransitionHintFromConnections(["match-cut", "ink-splash"], [], [], { duration: "short" })
+    expect(r).toContain("lasting approximately 1 second")
+  })
+
+  it("a no-op 'auto' beside a cut does not make the pick non-instant", () => {
+    const r = composeTransitionHintFromConnections(["auto", "smash-cut"], [], [], { duration: "long" })
+    expect(r).not.toContain("lasting approximately")
+  })
+})
+
+describe("instant transitions — on the wire catalog", () => {
+  it("the transition picker options carry instant: true on exactly the cut rows", () => {
+    const options = getPickerCatalog("transition")?.options ?? []
+    expect(options.length).toBe(TRANSITIONS.length)
+    expect(options.filter((o) => o.instant === true).map((o) => o.id).sort()).toEqual([...INSTANT_IDS].sort())
+    // Absent (not `false`) everywhere else, so a non-transition catalog's shape is unchanged.
+    for (const o of options) if (!INSTANT_IDS.includes(o.id)) expect(o).not.toHaveProperty("instant")
+  })
+
+  it("no other catalog grows the field", () => {
+    const camera = getPickerCatalog("camera-motion")?.options ?? []
+    expect(camera.length).toBeGreaterThan(0)
+    for (const o of camera) expect(o).not.toHaveProperty("instant")
+  })
+})

package/src/ad-creative-analysis.ts

@@ -0,0 +1,99 @@
+/**
+ * Per-ad creative analysis — the "expert competitor ad analyst" pass the
+ * social scraper nodes (Meta Ads first; TikTok / Instagram / LinkedIn next)
+ * can run on every ad they return. Node-agnostic on purpose: the input is
+ * "one creative + its copy + a little context", never a Meta-shaped ad.
+ *
+ * The model answers in a fixed JSON shape (the schema lives with the backend
+ * call site); this file owns the WORDS — what each field means and how to
+ * judge it — so the prompt can be tuned without touching the wire contract.
+ */
+
+/** The fields the analysis returns, in the order a reader wants them. */
+export const AD_CREATIVE_ANALYSIS_FIELDS = [
+  "assetType",
+  "format",
+  "visualHooks",
+  "audiences",
+  "graphicIdentity",
+  "copywritingHooks",
+  "usps",
+  "cta",
+  "summary",
+] as const
+export type AdCreativeAnalysisField = (typeof AD_CREATIVE_ANALYSIS_FIELDS)[number]
+
+export const AD_CREATIVE_ANALYSIS_SYSTEM_PROMPT = `You are an expert competitor ad analyst. You look at a competitor's ad — its creative (image or video poster frame) and its copy — and extract the relevant ad information into a structured summary a marketing team can act on.
+
+Judge from what is actually in the creative and copy; never invent claims that are not visible or written. Be concrete and specific (name the objects, colors, people, layouts, words), not generic ("eye-catching visuals"). Write in the language of the ad copy when it is not English, otherwise in English.
+
+Fill every field:
+- assetType: "static" (a still image), "motion" (a video — you see its poster frame), "carousel" (several creatives in one ad), or "unknown".
+- format: the placement the creative is built for — e.g. "in-feed", "story / reel (9:16)", "square feed", "banner / web", judged from its shape and framing.
+- visualHooks: the key visuals and visual angles used to stop the scroll (product close-up, before/after, face + eye contact, big number, screenshot, meme style, UGC selfie, text-on-image…). 2–6 short items.
+- audiences: who the ad represents or addresses (age band, gender, life situation, profession, interest, geography, pain point). 1–5 short items.
+- graphicIdentity: the graphic components — color palette, typography style, logo placement, layout system, illustration vs photo, brand consistency cues. One or two sentences.
+- copywritingHooks: the copywriting angles used in the visual text and in the body (curiosity, urgency, social proof, question, offer, fear of missing out, authority, humor…). 1–6 short items, each naming the angle and quoting or paraphrasing the line that carries it.
+- usps: the unique selling points the ad claims (price, speed, exclusivity, guarantee, results, features). 1–5 short items.
+- cta: the call to action — the button label and/or the closing line that tells the viewer what to do.
+- summary: two to four sentences: what the ad sells, to whom, with what hook, and why it likely works (or does not).`
+
+/**
+ * The organic-content twin of the ad prompt — for scraped social POSTS
+ * (Instagram / TikTok / LinkedIn), not paid ads. SAME output fields (so one
+ * schema and one UI serve both), read for organic content: hooks, audience,
+ * the value/benefit the post conveys (`usps`), and its ask (`cta` — "link in
+ * bio", "follow", a comment prompt, or none).
+ */
+export const POST_CONTENT_ANALYSIS_SYSTEM_PROMPT = `You are an expert social-media content analyst. You look at a single organic post — its creative (image or video cover frame) and its caption — and extract what a marketing team can learn from it into a structured summary.
+
+Judge from what is actually in the creative and caption; never invent claims that are not visible or written. Be concrete and specific (name the objects, colors, people, layouts, words), not generic ("engaging content"). Write in the language of the caption when it is not English, otherwise in English.
+
+Fill every field:
+- assetType: "static" (a still image), "motion" (a video / reel — you see its cover frame), "carousel" (a multi-image post), or "unknown".
+- format: the format the post is built for — e.g. "reel (9:16)", "square feed photo", "carousel", "portrait (4:5)", judged from its shape and framing.
+- visualHooks: the key visuals and visual angles used to stop the scroll (product close-up, before/after, face + eye contact, big text overlay, meme style, UGC selfie, trend/format…). 2–6 short items.
+- audiences: who the post represents or speaks to (age band, gender, life situation, profession, interest, geography, community). 1–5 short items.
+- graphicIdentity: the graphic components — color palette, typography style, logo / handle placement, layout, illustration vs photo, brand consistency cues. One or two sentences.
+- copywritingHooks: the caption / content angles (curiosity, storytelling, question, trend, humor, social proof, education, behind-the-scenes…). 1–6 short items, each naming the angle and quoting or paraphrasing the line that carries it.
+- usps: the value or benefit the post conveys to the viewer (entertainment, education, inspiration, a product benefit, a deal). 1–5 short items.
+- cta: the ask — the caption's call to action ("link in bio", "shop now", "follow", "comment below"), or "none" if the post makes none.
+- summary: two to four sentences: what the post is about, who it speaks to, with what hook, and why it likely performs (or does not).`
+
+export interface AdCreativeAnalysisInput {
+  /** Who is advertising (the Page / account name). */
+  readonly advertiser?: string
+  readonly headline?: string
+  readonly body?: string
+  readonly ctaLabel?: string
+  /** Where the ad points (the landing domain is enough). */
+  readonly landing?: string
+  /** Placements the ad ran on (Facebook, Instagram, TikTok…). */
+  readonly platforms?: readonly string[]
+  /** Creative shape already classified by the caller ("vertical", "square", "horizontal"). */
+  readonly creativeFormat?: string
+  /** "1 video, 2 images" — what the ad carries beyond the one frame the model sees. */
+  readonly mediaSummary?: string
+  /** The user's optional focus ("we sell running shoes — compare against our positioning"). */
+  readonly focus?: string
+}
+
+/**
+ * The user turn's text. The creative itself travels as a separate image
+ * block; this is everything else the analyst should know, one labelled
+ * line per fact, blanks left out.
+ */
+export function buildAdCreativeAnalysisUserText(input: AdCreativeAnalysisInput): string {
+  const lines: string[] = []
+  if (input.advertiser) lines.push(`Account / advertiser: ${input.advertiser}`)
+  if (input.headline) lines.push(`Headline: ${input.headline}`)
+  if (input.body) lines.push(`Body copy:\n${input.body}`)
+  if (input.ctaLabel) lines.push(`CTA button: ${input.ctaLabel}`)
+  if (input.landing) lines.push(`Landing: ${input.landing}`)
+  if (input.platforms && input.platforms.length > 0) lines.push(`Placements: ${input.platforms.join(", ")}`)
+  if (input.creativeFormat) lines.push(`Creative shape: ${input.creativeFormat}`)
+  if (input.mediaSummary) lines.push(`Media: ${input.mediaSummary}`)
+  lines.push("The attached image is the ad's creative (for a video, its poster frame).")
+  if (input.focus) lines.push(`\nAnalyst focus from the user: ${input.focus}`)
+  return lines.join("\n")
+}

package/src/catalog-packs.ts

@@ -125,8 +125,13 @@ function applyExtend(c: PickerCatalog, pack: CatalogPack): PickerCatalog {
 
 function applyDeny(c: PickerCatalog, denyIds: readonly string[]): PickerCatalog {
   const deny = new Set(denyIds)
-  if (c.kind === "single") return { ...c, options: (c.options ?? []).filter((o) => !deny.has(o.id)) }
-  return { ...c, dimensions: (c.dimensions ?? []).map((d) => ({ ...d, options: d.options.filter((o) => !deny.has(o.id)) })) }
+  // Single-value catalogs can also declare auxiliary dimensions (e.g.
+  // transition duration or motion speed). Those are curated too.
+  return {
+    ...c,
+    options: c.options?.filter((o) => !deny.has(o.id)),
+    dimensions: c.dimensions?.map((d) => ({ ...d, options: d.options.filter((o) => !deny.has(o.id)) })),
+  }
 }
 
 export function composePickerCatalogs(
@@ -145,6 +150,12 @@ export function composePickerCatalogs(
       else if (pack.mode === "extend") out = applyExtend(out, pack)
       else if (pack.mode === "deny") out = applyDeny(out, pack.denyIds ?? [])
     }
+    if (activePacks.some((p) => p.catalogId === c.catalogId) && out.defaultValue) {
+      const options = [...(out.options ?? []), ...(out.dimensions ?? []).flatMap((d) => d.options)]
+      if (!options.some((o) => o.id === out.defaultValue)) {
+        out = { ...out, defaultValue: out.options?.[0]?.id }
+      }
+    }
     return out
   })
 }

package/src/factory-presets/generate-video.ts

@@ -1113,4 +1113,26 @@ export const GENERATE_VIDEO_PRESETS: readonly FactoryPreset[] = [
         "{creature || A monstrous yeti with the physique and bone structure of a giant silverback gorilla}, {texture || thick matted white fur with snow crusted on the shoulders}, charges forward and smashes both fists into the ground. Low-angle ground shot looking up to emphasize its scale, heavy camera shake on impact, snow and debris bursting toward the lens. Overcast mountain light, volumetric breath mist around its muzzle. <deep guttural roar, the crunch of impact, debris scattering>（low ominous brass drone）Biologically accurate anatomy, epic cinematic scale. HD, sharp micro-details, stable picture, keep it subtitle-free, do not generate a watermark.",
     },
   },
+  // ── Video Editing ─────────────────────────────────────────────────────────
+  // Seedance 2.5 EDITS a wired reference clip when the prompt reads as an edit
+  // instruction. Edit mode takes the source clip's own ratio and length, so the
+  // preset ships the exact shape the provider requires — Adaptive + Auto
+  // (duration -1) — and the run goes through on the first submit. The user's
+  // own sentence is the whole prompt: the preset only supplies the pre & post
+  // text, with the clip bound as {video:1} (wire it into Video Refs).
+  {
+    id: "generate-video/edit-video",
+    name: "Edit Video",
+    description: "Change a wired clip by instruction — keeps its length, ratio and everything you don't mention.",
+    group: "Video Editing",
+    data: {
+      provider: "seedance-2-5",
+      aspectRatio: "adaptive",
+      duration: -1,
+      generateAudio: true,
+      promptPrefix: "edit {video:1} as follows:\n",
+      promptSuffix:
+        "Keep everything else in the clip unchanged: the same people, motion, framing and timing. Keep it subtitle-free, do not generate a watermark.",
+    },
+  },
 ]

package/src/index.ts

@@ -96,3 +96,6 @@ export * from "./surround-fill.js"
 // --- Start/end frame delivery: one plan for the dispatch and the editor ---
 export * from "./frame-delivery.js"
 export * from "./character-motion-diagnostics.js"
+
+// --- Per-ad creative analysis for the social scraper nodes ---
+export * from "./ad-creative-analysis.js"

package/src/node-prompt-fields.ts

@@ -128,6 +128,10 @@ export const NODE_PROMPT_FIELDS: Readonly<Record<string, PromptFieldSpec>> = {
   // Video Analysis — its focus hint is the editable prompt (renders a JSON scene
   // table, not a media preview → no inline editor).
   "video-analysis": { prompt: "analysisFocus", promptLabel: "Analysis focus", media: "video", inline: false },
+  // Edit Plan (podcast editing) — its free-text editing instructions are the
+  // editable prompt; the affixes wrap them. Emits an EDL (JSON), not a media
+  // preview, so no inline editor.
+  "edit-plan": { prompt: "instructions", promptLabel: "Editing instructions", media: "video", inline: false },
 }
 
 /** The prompt-field spec for a node type, or undefined if it has none. */

package/src/picker-catalogs.ts

@@ -119,6 +119,16 @@ export interface PickerOption {
    * `label` and inject `term`; they never derive it themselves.
    */
   readonly term: string
+  /**
+   * Transitions only: present (`true`) on a row whose mechanism is a CUT, so
+   * it takes no duration — see `Transition.instant` / `isInstantTransition`.
+   * A consumer that only reads this wire catalog (Studio builds the transition
+   * Duration lever from `getPickerCatalog("transition")`) hides that lever for
+   * such a row. Carried from the base catalog; a row a catalog pack ADDS has
+   * it only when the pack's own option says so, and absent means "has a
+   * duration" — the safe reading, since the composer then behaves as before.
+   */
+  readonly instant?: true
   /** Only present if the source catalog entry already carries a data icon/emoji/thumbnail field. */
   readonly icon?: string
 }
@@ -172,6 +182,8 @@ interface BaseCatalogEntry {
   readonly term?: string
   /** W1-a: see Person.adultOnly. Propagated verbatim into the flattened option. */
   readonly adultOnly?: true
+  /** Transitions: see `Transition.instant`. Propagated into the flattened option as `instant: true`. */
+  readonly instant?: boolean
 }
 
 /**
@@ -200,6 +212,7 @@ function toOptions<T extends BaseCatalogEntry>(
     if (e.description) opt.description = e.description
     if (categoryField) opt.category = e[categoryField] as unknown as string
     if (e.adultOnly) opt.adultOnly = true
+    if (e.instant) opt.instant = true
     return opt as PickerOption
   })
 }

package/src/ref-binding.ts

@@ -43,3 +43,22 @@ export const REF_BINDING = {
   frame: (n: number, role: "opening" | "closing") =>
     `Use @image_${n} as the ${role} (${role === "opening" ? "first" : "last"}) frame of the video.`,
 } as const
+
+/**
+ * The instruction that makes Seedance EDIT a wired clip rather than use it as a
+ * style reference — the Video to Video node's Seedance lane prepends it to the
+ * user's own sentence. Written with the EDITOR token (`{video:1}`) so it goes
+ * through the same reference resolver as any prompt: the source clip is the
+ * run's first reference video, so it resolves to `@video_1` on the wire. The
+ * instruction lands on its own line after it.
+ */
+export const SEEDANCE_VIDEO_EDIT_PREFIX = "edit {video:1} as follows:\n"
+
+/** The user's sentence, framed as an edit of the source clip. Idempotent: a
+ *  prompt that already opens with the instruction (a preset's pre text, a
+ *  hand-written one, either token spelling) is left alone. */
+export function buildSeedanceVideoEditPrompt(prompt: string | undefined): string {
+  const body = (prompt ?? "").trim()
+  if (/^edit\s+(?:\{video:1(?::[^}]*)?\}|@video_1(?!\w))/i.test(body)) return body
+  return `${SEEDANCE_VIDEO_EDIT_PREFIX}${body}`
+}