@nodaro/prompts 1.20.0 → 1.23.0

package/src/frame-delivery.ts

@@ -0,0 +1,106 @@
+/**
+ * HOW A START/END FRAME TRAVELS — one plan, read by both ends.
+ *
+ * A frame can reach a model two ways: as a real frame, or as a reference image
+ * bound in prose as the opening (or closing) frame. Which one is right is
+ * measured per model — the Seedance 2.0 family crop-zooms a frame 2% and drifts
+ * 11-26% darker within six frames, but holds its look from frame 0 when the same
+ * image rides as a reference; every other model measured reproduces the opening
+ * frame better as a frame (see `resolveFrameDelivery` in @nodaro/shared).
+ *
+ * The composition — where the frames sit in the reference list, which sentence
+ * binds them, when the switch is refused — lives HERE rather than at the
+ * dispatch site, because two places need the same answer:
+ *
+ *   - `backend/src/lib/video-frame-dispatch.ts` builds the actual request,
+ *   - the editor's config panel tells the user which mode their node will run in.
+ *
+ * When those two disagree the panel lies, which is worse than having no panel
+ * text at all. One function, two callers, no drift.
+ */
+import { VIDEO_REF_LIMITS_BY_PROVIDER, resolveFrameDelivery, type FrameDelivery } from "@nodaro/shared"
+import { REF_BINDING } from "./ref-binding.js"
+import { promptBindsFirstFrame } from "./seedance-2-inputs.js"
+
+export interface FrameDeliveryPlanArgs {
+  readonly provider: string | undefined
+  /** The node's / caller's choice. `auto` (or absent) resolves per model. */
+  readonly requested?: FrameDelivery
+  /** Whether the model accepts reference images at all. */
+  readonly supportsReferenceImages: boolean
+  readonly startFrameUrl?: string
+  readonly endFrameUrl?: string
+  /** The user's OWN reference images, in their existing order. */
+  readonly userReferenceUrls?: readonly string[]
+  /** Consulted only to avoid a duplicate opening-frame sentence. */
+  readonly prompt?: string
+}
+
+export interface FrameDeliveryPlan {
+  /** What will actually happen — never `auto`. */
+  readonly delivery: Exclude<FrameDelivery, "auto">
+  /** The full reference list to send. Equals the user's own list under `frame`. */
+  readonly referenceImageUrls: readonly string[]
+  /** Sentence(s) to append to the prompt. Empty under `frame`. */
+  readonly promptSuffix: string
+  /** Set when reference delivery was WANTED but refused, so a caller can say why. */
+  readonly refusedReason?: "no-reference-support" | "image-cap"
+}
+
+/**
+ * Resolve delivery and compose the request shape that follows from it.
+ *
+ * Two refusals, both deliberate:
+ *   - a model with no reference-image support keeps frame mode (there is nowhere
+ *     for the frame to go);
+ *   - a switch that would push past the model's image cap keeps frame mode,
+ *     because the alternative is dropping one of the USER's reference images to
+ *     make room for ours.
+ *
+ * The frames are appended AFTER the user's own images so their `@image_N`
+ * ordinals never shift, and the opening sentence is skipped when the prompt
+ * already binds its own first frame — a second binding at another position
+ * dilutes the first back into coin-flip behaviour (field finding 2026-07-20).
+ */
+export function planFrameDelivery(args: FrameDeliveryPlanArgs): FrameDeliveryPlan {
+  const userRefs = (args.userReferenceUrls ?? []).filter(Boolean)
+  const requested = args.requested ?? "auto"
+  const delivery = resolveFrameDelivery({
+    provider: args.provider,
+    requested,
+    supportsReferenceImages: args.supportsReferenceImages,
+  })
+
+  const frames = [args.startFrameUrl, args.endFrameUrl].filter((u): u is string => Boolean(u))
+
+  if (delivery === "frame" || frames.length === 0) {
+    return {
+      delivery: "frame",
+      referenceImageUrls: userRefs,
+      promptSuffix: "",
+      ...(requested === "reference" && !args.supportsReferenceImages
+        ? { refusedReason: "no-reference-support" as const }
+        : {}),
+    }
+  }
+
+  const cap = VIDEO_REF_LIMITS_BY_PROVIDER[args.provider ?? ""]?.images
+  if (cap !== undefined && userRefs.length + frames.length > cap) {
+    return { delivery: "frame", referenceImageUrls: userRefs, promptSuffix: "", refusedReason: "image-cap" }
+  }
+
+  const referenceImageUrls = [...userRefs]
+  const sentences: string[] = []
+  if (args.startFrameUrl) {
+    referenceImageUrls.push(args.startFrameUrl)
+    if (!promptBindsFirstFrame(args.prompt)) {
+      sentences.push(REF_BINDING.frame(referenceImageUrls.length, "opening"))
+    }
+  }
+  if (args.endFrameUrl) {
+    referenceImageUrls.push(args.endFrameUrl)
+    sentences.push(REF_BINDING.frame(referenceImageUrls.length, "closing"))
+  }
+
+  return { delivery: "reference", referenceImageUrls, promptSuffix: sentences.join(" ") }
+}

package/src/index.ts

@@ -92,3 +92,10 @@ export * from "./object-asset-presets.js"
 export * from "./factory-snippets/index.js"
 export * from "./picker-wiring.js"
 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/parameter-prompt-hint.ts

@@ -102,6 +102,28 @@ function extractCharacterRefMinor(node: HintNodeLike): boolean {
   return REF_DESCRIPTION_FIELDS.some((field) => containsMinorAgeHint(asStr(d[field])))
 }
 
+/** The preview, diagnostics and execution use identical graph bindings. */
+export function getCharacterMotionBindings(node: HintNodeLike, ctx?: HintGraphContext) {
+  const targetNames: string[] = []
+  const partnerNames: string[] = []
+  const targetIds = new Set<string>()
+  const partnerIds = new Set<string>()
+  let subjectMinor = false
+  for (const edge of ctx?.edges ?? []) {
+    if (edge.target !== node.id || (edge.targetHandle !== "target" && edge.targetHandle !== "partner")) continue
+    const src = ctx?.nodes.find(n => n.id === edge.source)
+    if (!src) continue
+    if (edge.targetHandle === "target") targetIds.add(src.id)
+    else partnerIds.add(src.id)
+    if (extractCharacterRefMinor(src)) subjectMinor = true
+    const name = extractCharacterMotionRefName(src)
+    if (!name) continue
+    const names = edge.targetHandle === "target" ? targetNames : partnerNames
+    if (!names.includes(name)) names.push(name)
+  }
+  return { targetNames, partnerNames, subjectMinor, selfPairing: [...targetIds].some(id => partnerIds.has(id)) }
+}
+
 /** Compose `[preText, mainHint, postText]` into a comma-joined string,
  *  honoring the user's free-text fragments around the structured hint.
  *  Helpers like `getStylePromptHint` that already include preText/postText
@@ -261,23 +283,7 @@ function resolveParameterHint(
     if (!ctx) {
       return withCustomText(data, composeCharacterMotionHintFromConnections(motionId, [], [], timing, mode))
     }
-    const targetNames: string[] = []
-    const partnerNames: string[] = []
-    // Minor-age floor: ANY ref wired to target or partner that describes a
-    // minor drops every adultOnly move from the composed sequence.
-    let subjectMinor = false
-    for (const edge of ctx.edges) {
-      if (edge.target !== node.id) continue
-      if (edge.targetHandle !== "target" && edge.targetHandle !== "partner") continue
-      const src = ctx.nodes.find((n) => n.id === edge.source)
-      if (!src) continue
-      // Before the name check: an unnamed ref that describes a minor still floors.
-      if (!subjectMinor && extractCharacterRefMinor(src)) subjectMinor = true
-      const name = extractCharacterMotionRefName(src)
-      if (!name) continue
-      if (edge.targetHandle === "target") targetNames.push(name)
-      else partnerNames.push(name)
-    }
+    const { targetNames, partnerNames, subjectMinor } = getCharacterMotionBindings(node, ctx)
     return withCustomText(
       data,
       composeCharacterMotionHintFromConnections(motionId, targetNames, partnerNames, timing, mode, { subjectMinor }),

package/src/picker-catalogs.ts

@@ -1,3 +1,4 @@
+import type { CharacterMotionMetadata } from "./character-motion/types.js"
 /**
  * Public, discoverable registry of the parameter-picker catalogs.
  *
@@ -98,6 +99,9 @@ import { setComposedCatalogResolver } from "./catalog-overlay.js"
 import { deriveTerm, resolveTerm } from "./term.js"
 
 export interface PickerOption {
+  /** Character Motion only: authored prerequisites, state and search metadata. */
+  readonly motion?: CharacterMotionMetadata
+
   readonly id: string
   readonly label: string
   readonly description?: string
@@ -115,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
 }
@@ -168,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
 }
 
 /**
@@ -196,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
   })
 }
@@ -604,7 +621,10 @@ const SINGLE_CATALOGS: readonly PickerCatalog[] = [
     defaultValue: "auto",
     categoryOrder: CHARACTER_MOTION_CATEGORY_ORDER,
     categoryLabels: CHARACTER_MOTION_CATEGORY_LABELS,
-    options: toOptions(CHARACTER_MOTIONS, "category"),
+    options: toOptions(CHARACTER_MOTIONS, "category").map((option, index) => {
+      const { id: _id, label: _label, category: _category, description: _description, promptHint: _hint, term: _term, adultOnly: _adult, twoPerson: _duo, ...motion } = CHARACTER_MOTIONS[index]!
+      return { ...option, motion }
+    }),
     // Position + Pace, this node's own wording (a movement begins / plays out;
     // an effect manifests; a transition occurs) — never the sibling rows.
     dimensions: perFieldDims([
@@ -939,8 +959,9 @@ function projectOption(o: PickerOption, detail: PickerCatalogDetail): ProjectedP
         promptHint: o.promptHint,
         term: o.term,
         icon: o.icon,
+        ...(o.motion ? { motion: o.motion } : {}),
       }
-    : { id: o.id, label: o.label, category: o.category, term: o.term, icon: o.icon }
+    : { id: o.id, label: o.label, category: o.category, term: o.term, icon: o.icon, ...(o.motion ? { motion: o.motion } : {}) }
 }
 
 /** Project a catalog to the wire shape: compact by default, optional category/field filter. */

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}`
+}

package/src/transitions.ts

@@ -41,6 +41,18 @@ export interface Transition {
    * "invisible cut"). Everywhere else the label IS the term.
    */
   readonly term?: string
+  /**
+   * `true` on rows whose mechanism IS A CUT — the change happens between two
+   * frames, so it has no duration to time. A duration clause ("lasting
+   * approximately 1 second") on such a row tells the video model to spend a
+   * second on the change, and it obliges with a dissolve: a match cut rendered
+   * as a 1.75 s cross-dissolve in QA. The composer therefore skips the duration
+   * lever when every picked transition is instant, and consumers (the picker
+   * UI, Studio) read `isInstantTransition` to hide that lever. Position and
+   * intensity still apply — WHERE the cut lands, and how hard it hits, are
+   * real choices.
+   */
+  readonly instant?: boolean
 }
 
 /**
@@ -73,7 +85,7 @@ export const TRANSITIONS: ReadonlyArray<Transition> = [
   // ============================================================================
   { id: "auto",              label: "Auto",              category: "standard", description: "Let the model choose", promptHint: "" },
   { id: "none",              label: "None / Hard Cut",   category: "standard", description: "Instantaneous switch, no transition",
-    promptHint: "no transition, hard cut, instantaneous switch from first shot to second shot", term: "hard cut" },
+    promptHint: "no transition, hard cut, instantaneous switch from first shot to second shot", term: "hard cut" , instant: true },
   { id: "cross-dissolve",    label: "Cross-Dissolve",    category: "standard", description: "Gradual blend between shots",
     promptHint: "smooth cross-dissolve transition where the first shot gradually fades out as the second shot fades in" },
   { id: "fade-to-black",     label: "Fade to Black",     category: "standard", description: "Darkens to black, second emerges",
@@ -81,11 +93,11 @@ export const TRANSITIONS: ReadonlyArray<Transition> = [
   { id: "fade-to-white",     label: "Fade to White",     category: "standard", description: "Blooms to white, second emerges",
     promptHint: "fade to white: the first shot brightens until the frame is pure white, then the second shot resolves out of the white" },
   { id: "snap-to-black",     label: "Snap to Black",     category: "standard", description: "Instant cut to full black for a beat, then the next shot",
-    promptHint: "snap to black: the first shot cuts instantly to full black with no fade, the frame holds pure black for a single beat, then the second shot cuts in at full brightness", term: "snap to black" },
+    promptHint: "snap to black: the first shot cuts instantly to full black with no fade, the frame holds pure black for a single beat, then the second shot cuts in at full brightness", term: "snap to black" , instant: true },
   { id: "match-cut",         label: "Match Cut",         category: "standard", description: "Shape or motion match across shots",
-    promptHint: "match cut: the final composition of the first shot matches the opening composition of the second shot in shape, color, and motion, so the cut feels like a visual rhyme" },
+    promptHint: "match cut: the final composition of the first shot matches the opening composition of the second shot in shape, color, and motion, so the cut feels like a visual rhyme" , instant: true },
   { id: "smash-cut",         label: "Smash Cut",         category: "standard", description: "Jarring abrupt cut between contrasting shots",
-    promptHint: "smash cut: an abrupt jarring transition between two visually or tonally contrasting shots with no fade, on a beat" },
+    promptHint: "smash cut: an abrupt jarring transition between two visually or tonally contrasting shots with no fade, on a beat" , instant: true },
   { id: "iris",              label: "Iris",              category: "standard", description: "Circular iris closes, then opens on second",
     promptHint: "iris transition: a circular vignette closes inward over the first shot until the frame is black, then opens outward to reveal the second shot", term: "iris wipe" },
   { id: "wipe",              label: "Wipe",              category: "standard", description: "Linear wipe replaces first shot",
@@ -93,11 +105,11 @@ export const TRANSITIONS: ReadonlyArray<Transition> = [
   { id: "roll-transition",   label: "Roll",              category: "standard", description: "Frame rolls 90-180°, second shot upright on landing",
     promptHint: "the frame rolls along the camera axis with a smooth 90 to 180 degree rotation, motion-blurred during the roll, and as the rotation completes the new shot is upright and stable in frame", term: "camera roll transition" },
   { id: "seamless-match",    label: "Seamless Match",    category: "standard", description: "Hidden cut disguised by matched motion and color",
-    promptHint: "hidden seamless transition: the camera motion, color palette, and on-screen motion at the end of the first shot continue exactly across the cut into the second shot, so the boundary is invisible and the two shots feel like one unbroken take", term: "invisible cut" },
+    promptHint: "hidden seamless transition: the camera motion, color palette, and on-screen motion at the end of the first shot continue exactly across the cut into the second shot, so the boundary is invisible and the two shots feel like one unbroken take", term: "invisible cut" , instant: true },
   { id: "whip-pan",          label: "Whip Pan",          category: "standard", description: "Camera whips sideways into blur, next shot rides the same direction",
     promptHint: "whip pan transition: the camera whips sideways at high speed, smearing the frame into heavy horizontal motion blur, and the second shot enters already travelling in the same direction before it settles into its framing", term: "whip pan" },
   { id: "jump-cut",          label: "Jump Cut",          category: "standard", description: "Same framing, time skips forward",
-    promptHint: "jump cut: the framing, lens, and camera position stay identical across the cut while time skips abruptly forward, so the subject snaps to a new position inside what still reads as one continuous shot", term: "jump cut" },
+    promptHint: "jump cut: the framing, lens, and camera position stay identical across the cut while time skips abruptly forward, so the subject snaps to a new position inside what still reads as one continuous shot", term: "jump cut" , instant: true },
 
   // ============================================================================
   // TIME — 8 entries — temporal shifts (same or related scene, different time, or memory)
@@ -219,11 +231,11 @@ export const TRANSITIONS: ReadonlyArray<Transition> = [
   { id: "vehicle-explosion", label: "Vehicle Explosion",  category: "physics", description: "Vehicle detonates in foreground, scene changes behind",
     promptHint: "a vehicle in the foreground erupts in a violent explosion of fire and twisted metal, the fireball expands toward the camera and washes the frame in orange flame, and as the smoke parts the second scene resolves" },
   { id: "jump-match",        label: "Jump Match",         category: "physics", description: "Subject jumps, landing matches into new scene",
-    promptHint: "the subject jumps upward and out of frame at the end of the first shot, with matched velocity the camera follows the arc, and on landing the subject is in a new location seamlessly continuing the same jump", term: "match cut on a jump" },
+    promptHint: "the subject jumps upward and out of frame at the end of the first shot, with matched velocity the camera follows the arc, and on landing the subject is in a new location seamlessly continuing the same jump", term: "match cut on a jump" , instant: true },
   { id: "hand-swipe",        label: "Hand Swipe",         category: "physics", description: "Hand swipes across lens, scene changes during occlusion",
     promptHint: "a hand sweeps across the camera lens at close range, fully occluding the frame in motion blur for a single beat, and as the hand exits the opposite side the scene has changed to the new setting" },
   { id: "action-relay",      label: "Action Match",      category: "physics", description: "Subject exits on an action and lands in the new scene mid-move",
-    promptHint: "match cut on action: the subject exits the frame on a committed action — a stride, a throw, a turn — and enters the new scene on the same beat continuing that movement at matched speed and direction, so the action carries unbroken across the cut", term: "match cut on action" },
+    promptHint: "match cut on action: the subject exits the frame on a committed action — a stride, a throw, a turn — and enters the new scene on the same beat continuing that movement at matched speed and direction, so the action carries unbroken across the cut", term: "match cut on action" , instant: true },
 
   // ============================================================================
   // LIGHT — 8 entries — flash and lens FX
@@ -314,6 +326,23 @@ export function getTransitionTerm(id: string | undefined | null): string {
 
 export const TRANSITION_IDS: ReadonlyArray<string> = TRANSITIONS.map((t) => t.id)
 
+/**
+ * Whether a transition is a CUT — instantaneous by nature, so it takes no
+ * duration (see `Transition.instant`). Reads through `getTransition`, so it
+ * answers for the same entry every other getter describes; an unknown id, the
+ * no-op "auto" and an empty value are all `false`.
+ *
+ * A multi-pick (`string[]`) is instant only when EVERY picked id is: a cut
+ * paired with a dissolve still has a dissolve to time.
+ */
+export function isInstantTransition(
+  id: string | ReadonlyArray<string> | undefined | null,
+): boolean {
+  const ids = typeof id === "string" ? [id] : id ? [...id] : []
+  if (ids.length === 0) return false
+  return ids.every((one) => getTransition(one)?.instant === true)
+}
+
 // ---------------------------------------------------------------------------
 // Graph-aware composer — start/end input handles + timing fields + multi-pick
 // ---------------------------------------------------------------------------
@@ -395,6 +424,8 @@ const INTENSITY_CLAUSES = clausesOf(TRANSITION_INTENSITIES)
  * - 0 hints (no transition, empty array, or all-empty hints) → ""
  * - n base hints joined with ", and "
  * - Timing/start/end clauses apply ONCE at the outer layer, not per-id
+ * - The duration clause is dropped when every picked id is instant (a cut —
+ *   see `isInstantTransition`); position and intensity still apply
  * - null input is treated like undefined (falsy short-circuit → returns "")
  *
  * @param mode `"compact"` builds the base from each transition's short
@@ -416,7 +447,10 @@ export function composeTransitionHintFromConnections(
   // ONLY the base fragment swaps in compact mode — the multi-pick join, the
   // timing clauses and the start/end clauses below are identical either way.
   const resolveBase = mode === "compact" ? getTransitionTerm : getTransitionPromptHint
-  const baseHints = ids.map(resolveBase).filter((h) => h.length > 0)
+  // Only ids that contribute a base hint count below — a no-op "auto" beside a
+  // cut must not make the pick look non-instant.
+  const picked = ids.filter((id) => resolveBase(id).length > 0)
+  const baseHints = picked.map(resolveBase)
   if (baseHints.length === 0) return ""
 
   const combinedBase = baseHints.join(", and ")
@@ -425,7 +459,10 @@ export function composeTransitionHintFromConnections(
   if (timing?.position && timing.position !== "auto") {
     parts.push(POSITION_CLAUSES[timing.position])
   }
-  if (timing?.duration && timing.duration !== "auto") {
+  // A cut has no duration: "lasting approximately 1 second" on a match cut
+  // makes the model render a one-second dissolve. Skipped only when EVERY
+  // picked id is instant — a mixed pick still has a non-cut to time.
+  if (timing?.duration && timing.duration !== "auto" && !isInstantTransition(picked)) {
     parts.push(DURATION_CLAUSES[timing.duration])
   }
   if (timing?.intensity && timing.intensity !== "auto") {

package/src/video-reference-resolver.ts

@@ -46,7 +46,7 @@ import { insertBeforeStyleSection } from "./prompt-style-section.js"
 // The binding surface string and the id-addressed token resolver live in their
 // own modules (see them for the contracts); re-exported here so every existing
 // importer of this module — and the package index's `export *` — keeps working.
-export { REF_BINDING, identityRefsSentence } from "./ref-binding.js"
+export { REF_BINDING, identityRefsSentence, SEEDANCE_VIDEO_EDIT_PREFIX, buildSeedanceVideoEditPrompt } from "./ref-binding.js"
 export { resolveRefIdTokens, type RefIdTokenContext } from "./ref-id-tokens.js"