@nodaro/shared 2.3.0 → 2.7.0

package/src/model-constants.ts

@@ -558,6 +558,7 @@ export const IMAGE_GEN_PROVIDERS = [
   "nano-banana-2",
   "nano-banana-2-lite",
   "grok",
+  "grok-2",
   "gpt-image",
   "gpt-image-2",
   "imagen4",
@@ -605,8 +606,13 @@ export const IMAGE_I2I_PROVIDERS = [
   "kontext-multi",
   // BFL Flux 2 Pro — runs through Replicate with safety_tolerance=5 (max for Pro)
   "flux-2-pro",
+  // BFL FLUX Fill Pro — dedicated masked inpainting via Replicate (white = edit area)
+  "flux-fill",
   // BFL Flux 2 Max — runs through Replicate with safety_tolerance=5, up to 8 refs
   "flux-2-max",
+  // BFL FLUX Fill Pro — dedicated inpainting via Replicate (image + mask + prompt,
+  // white = edit area). Second mask-capable i2i provider alongside ideogram-edit.
+  "flux-fill",
 ] as const
 
 /** Image editing providers (upscale, remove bg, etc.) */
@@ -618,8 +624,29 @@ export const IMAGE_EDIT_PROVIDERS = [
   // grok-upscale takes a prior Grok generation's task_id (NOT an image URL) —
   // see edit-image route for the taskId-vs-imageUrl branching.
   "grok-upscale",
+  // Grok Imagine 2 task-chained ops — same task_id contract as grok-upscale.
+  // grok-2-edit: prompt edit of a prior grok-2 generation, optionally region-
+  // targeted via mask indexes from grok-2-segment. grok-2-segment: FREE named
+  // segment-mask map of a prior grok-2 generation.
+  "grok-2-edit",
+  "grok-2-segment",
 ] as const
 
+/**
+ * Edit providers that take a PRIOR KIE Grok generation's task id instead of
+ * an image URL. Single source of truth for the taskId-vs-imageUrl branching:
+ * the edit-image route requires `taskId` (imageUrl alone is rejected), the
+ * worker routes `taskId` into the provider call, and the KIE model config
+ * (`imageParam: "task_id"`) places it in the request body. Membership here
+ * must match the KIE configs with `imageParam: "task_id"` — guarded by
+ * backend/src/routes/__tests__/edit-image.test.ts.
+ */
+export const TASK_CHAINED_EDIT_PROVIDERS: ReadonlySet<string> = new Set([
+  "grok-upscale",
+  "grok-2-edit",
+  "grok-2-segment",
+])
+
 /** Modify image providers (I2I + edit-with-prompt) */
 export const MODIFY_IMAGE_PROVIDERS = [
   ...IMAGE_I2I_PROVIDERS,
@@ -1039,7 +1066,7 @@ export type VoiceDesignModel = typeof VOICE_DESIGN_MODELS[number]
 export const DEFAULT_VOICE_DESIGN_MODEL: VoiceDesignModel = "eleven_ttv_v3"
 
 /** I2I providers that support mask-based inpainting */
-export const I2I_MASK_SUPPORT = new Set(["ideogram-edit"])
+export const I2I_MASK_SUPPORT = new Set(["ideogram-edit", "flux-fill"])
 
 /**
  * Mask edit tier per image-gen provider (single source of truth for inpaint).
@@ -1066,6 +1093,7 @@ export const IMAGE_MASK_MODE: Record<ImageGenProvider, ImageMaskMode> = {
   "flux": "composite",
   "flux-flex": "composite",
   "grok": "composite",
+  "grok-2": "composite",
   "imagen4": "composite",
   "imagen4-fast": "composite",
   "imagen4-ultra": "composite",

package/src/node-default-mappings.ts

@@ -184,8 +184,9 @@ const QUALITY_MAP: Record<string, QualityMapping> = {
   "seedance-2":          { field: "resolution", values: { low: "720p", mid: "1080p", high: "1080p" } },
   "seedance-2-fast":     { field: "resolution", values: { low: "480p", mid: "720p", high: "720p" } },
   "seedance-2-mini":     { field: "resolution", values: { low: "480p", mid: "720p", high: "720p" } },
-  // Seedance 2.5 tops out at 720p on KIE (1080p/4k probe-rejected 2026-08-08).
-  "seedance-2-5":        { field: "resolution", values: { low: "480p", mid: "720p", high: "720p" } },
+  // Seedance 2.5 spans 480p/720p/1080p on KIE (1080p accepted since the
+  // 2026-08-17 re-probe; 4k still rejected), so each quality rung gets its own tier.
+  "seedance-2-5":        { field: "resolution", values: { low: "480p", mid: "720p", high: "1080p" } },
   "wan-2.7-i2v":         { field: "resolution", values: { low: "720p", mid: "1080p", high: "1080p" } },
   "wan-2.7-t2v":         { field: "resolution", values: { low: "720p", mid: "1080p", high: "1080p" } },
   "happyhorse":          { field: "resolution", values: { low: "720p", mid: "1080p", high: "1080p" } },

package/src/pipeline-defaults.ts

@@ -65,6 +65,7 @@ export function validateModeActivation(
 // Tier → max parallel pipelines (Architecture §5.4)
 export const TIER_PIPELINE_PARALLELISM: Record<string, number> = {
   free: 0,
+  payg: 1, // derived tier — pipeline entitlements copy basic's
   basic: 1,
   standard: 2,
   pro: 3,
@@ -80,6 +81,7 @@ export const TIER_PIPELINE_PARALLELISM: Record<string, number> = {
 // the user paid for, instead of the intended two-thirds.
 export const TIER_MAX_PIPELINE_COST_CREDITS: Record<string, number> = {
   free: 0,
+  payg: 3000, // derived tier — copies basic
   basic: 3000,
   standard: 8000,
   pro: 20000,

package/src/reduce-strategy-registry.ts

@@ -17,12 +17,23 @@ export type ReduceStrategy<TConfig = unknown> = {
   readonly defaultConfig: TConfig
   readonly outputType: OutputType
   readonly creditCostKey: string
+  /**
+   * The strategy calls an LLM (its judge model). Everything that treats
+   * "an LLM strategy" specially — the connected-install cloud proxy, the
+   * tiered credit id — reads this rather than matching on the id, so a new
+   * LLM strategy is covered by declaring it here.
+   */
+  readonly usesLlm?: boolean
 }
 
+// User-facing copy lives HERE (single source of truth) and flows into the node
+// body, the config panel dropdown, the SDK docs and the MCP tool. Written for
+// the person building the flow, not the engine: say what happens to their
+// candidates, never "survivor" / "fan-in" / "reduce" / model names.
 const PICK_BEST_LLM_STRATEGY = {
   id: "pick-best-llm",
-  label: "Pick best (LLM judge)",
-  description: "Sonnet picks the best item against your criteria.",
+  label: "AI picks the best",
+  description: "AI compares every candidate against your criteria and picks one.",
   configSchema: z.object({
     // Default to the sensible "best quality" criteria when omitted (matches
     // defaultConfig) so a reduce({strategyId:"pick-best-llm"}) call with no
@@ -30,16 +41,23 @@ const PICK_BEST_LLM_STRATEGY = {
     // rejects via min(1).
     criteria: z.string().min(1, "criteria cannot be empty").default("Pick the highest-quality result."),
     inputKind: z.enum(["text", "image-url"]).default("text"),
+    // The judge model, like every other LLM node (llmModel + LlmModelSelect).
+    // Optional: omitted → LLM_FEATURE_DEFAULTS["pick-best-llm"]. Validated
+    // against LLM_MODEL_IDS at the route (the registry can't import the model
+    // list without a cycle), and its tier drives the credit price via
+    // buildLlmCreditIdentifier — economy / standard / premium.
+    llmModel: z.string().optional(),
   }),
   defaultConfig: { criteria: "Pick the highest-quality result.", inputKind: "text" as const },
   outputType: "text" as OutputType,
   creditCostKey: "reduce:pick-best-llm",
-} as const satisfies ReduceStrategy<{ criteria: string; inputKind: "text" | "image-url" }>
+  usesLlm: true,
+} as const satisfies ReduceStrategy<{ criteria: string; inputKind: "text" | "image-url"; llmModel?: string }>
 
 const CONCAT_STRATEGY = {
   id: "concat",
-  label: "Concatenate",
-  description: "Join all survivors with a separator.",
+  label: "Join into one text",
+  description: "Puts every candidate into a single text, one after another, with a separator between them.",
   configSchema: z.object({ separator: z.string().default("\n\n") }),
   defaultConfig: { separator: "\n\n" },
   outputType: "text" as OutputType,
@@ -48,8 +66,8 @@ const CONCAT_STRATEGY = {
 
 const FIRST_NON_EMPTY_STRATEGY = {
   id: "first-non-empty",
-  label: "First non-empty",
-  description: "Return the first survivor (empty strings filtered).",
+  label: "First that has content",
+  description: "Takes the first candidate that is not empty and ignores the rest.",
   configSchema: z.object({}),
   defaultConfig: {},
   outputType: "text" as OutputType,
@@ -58,8 +76,8 @@ const FIRST_NON_EMPTY_STRATEGY = {
 
 const COUNT_STRATEGY = {
   id: "count",
-  label: "Count",
-  description: "Return how many survivors came through.",
+  label: "Count them",
+  description: "Outputs how many candidates arrived.",
   configSchema: z.object({}),
   defaultConfig: {},
   outputType: "data" as OutputType,
@@ -68,8 +86,8 @@ const COUNT_STRATEGY = {
 
 const VOTE_STRATEGY = {
   id: "vote",
-  label: "Majority vote",
-  description: "Return the most common survivor (ties → first).",
+  label: "Most common answer",
+  description: "Picks the candidate that appears most often (ties go to the first).",
   configSchema: z.object({ caseSensitive: z.boolean().default(false) }),
   defaultConfig: { caseSensitive: false },
   outputType: "text" as OutputType,
@@ -78,8 +96,8 @@ const VOTE_STRATEGY = {
 
 const MERGE_JSON_STRATEGY = {
   id: "merge-json",
-  label: "Merge JSON",
-  description: "Parse each survivor as JSON and merge into one object.",
+  label: "Merge JSON objects",
+  description: "Reads every candidate as JSON and merges them into one object.",
   configSchema: z.object({ strategy: z.enum(["deep", "shallow"]).default("deep") }),
   defaultConfig: { strategy: "deep" as const },
   outputType: "data" as OutputType,

package/src/video-analysis.ts

@@ -100,6 +100,21 @@ export type VideoAnalysisTransition = (typeof VIDEO_ANALYSIS_TRANSITIONS)[number
  * the majority of shots.
  */
 export const VIDEO_ANALYSIS_SPEED_EFFECTS = ["slow-motion", "ramp-in", "ramp-out", "timelapse", "freeze", "reverse"] as const
+
+/** CHRONICLE TIME (2026-08-17): the STORY clock, per scene, as read from the
+ *  pictures — light, sky, practicals. "ambiguous" is the honest answer for a
+ *  windowless interior; guessing day is exactly the kind of tidy inference
+ *  the analysis doctrine forbids. */
+export const VIDEO_ANALYSIS_TIMES_OF_DAY = ["dawn", "day", "dusk", "night", "ambiguous"] as const
+
+/** STORY JUMP since the PREVIOUS scene in the list: how much narrative time
+ *  passed across the cut, judged from evidence (wardrobe change, aged
+ *  subjects, season, a title card), not from the cut itself. Time outranks
+ *  location for continuity judgements (same person, new place, continuous
+ *  time ⇒ same outfit; same place, years later ⇒ anything may differ), which
+ *  is why this is a structured field and not prose. "unclear" is the honest
+ *  default; the FIRST scene of a clip is "continuous" by convention. */
+export const VIDEO_ANALYSIS_STORY_JUMPS = ["continuous", "same-day", "another-day", "years-later", "unclear"] as const
 export type VideoAnalysisSpeedEffect = (typeof VIDEO_ANALYSIS_SPEED_EFFECTS)[number]
 
 /**
@@ -268,6 +283,12 @@ const windowSceneBase = z.object({
   angle: z.enum(VIDEO_ANALYSIS_SHOT_ANGLES).optional(),
   /** Time manipulation. Absent ⇒ normal speed. */
   speed: z.enum(VIDEO_ANALYSIS_SPEED_EFFECTS).optional(),
+  /** CHRONICLE TIME (2026-08-17) — see the consts' docstrings. Both optional:
+   *  absent on every pre-2.6.0 analysis, and legitimately absent when the
+   *  analyser cannot read the clock. Enum + optional keeps the window decode
+   *  grammar congruence-safe (no ints, no maxItems). */
+  timeOfDay: z.enum(VIDEO_ANALYSIS_TIMES_OF_DAY).optional(),
+  storyJump: z.enum(VIDEO_ANALYSIS_STORY_JUMPS).optional(),
   visual: z.string().min(1),
   /**
    * Text burned into the PICTURE of this shot — titles, captions, lower-thirds,
@@ -521,3 +542,52 @@ export function aspectRatioFromDims(w: number, h: number): string {
   const g = gcd(Math.round(w), Math.round(h))
   return `${Math.round(w) / g}:${Math.round(h) / g}`
 }
+
+/** Sung-vocal evidence in a music layer's gen-ready description. Word-bounded
+ *  and deliberately WITHOUT bare "song"/"music" (an instrumental bed is
+ *  routinely described as a "pop song"). Quoted text of some length inside a
+ *  music layer counts too — analysers quote lyrics. */
+const MUSIC_VOCAL_RE = /\b(?:lyrics?|sung|sings?|singing|vocals?|chorus|verse|rap(?:ping|ped)?|a cappella)\b/i
+const MUSIC_VOCAL_QUOTE_RE = /["\u201c][^"\u201d]{6,}["\u201d]/
+/** Negated-vocal phrasing — a layer matching this contributes NO vocal
+ *  evidence (it does not veto other layers). */
+const MUSIC_NO_VOCAL_RE = /\b(?:no|without|non)[- ](?:vocals?|lyrics?|singing)\b|\binstrumental\b|\bwordless\b/i
+
+/**
+ * MUSIC-VIDEO INFERENCE (2026-08-17): is this clip a music video — one whose
+ * soundtrack IS the content, to be taken as-is with no stem separation?
+ *
+ * Lives in SHARED because two sides must agree BYTE-FOR-BYTE on the answer:
+ * the recast route derives `music.mode` from it server-side, and the client
+ * both prices the original-audio prep and GUARDS on the server's derived mode
+ * at generate time — two hand-written copies of this heuristic would drift
+ * into that guard firing on honest runs. Deterministic, throw-proof on any
+ * malformed analysis (absent fields ⇒ false).
+ *
+ * The rule is conservative toward FALSE (a false positive keeps unwanted
+ * dialogue in the render; a false negative merely runs the separation, which
+ * was yesterday's default): at least 4 scenes, at least 80% of scenes carry a
+ * music layer, and at least one music layer carries sung-vocal evidence that
+ * is not negated ("instrumental", "no vocals").
+ *
+ * An EXPLICIT analyze-time flag always wins — callers use
+ * `flag === true || inferMusicVideo(analysis)` and never let a cached false
+ * suppress the inference (the flag can only ever be set true; false means
+ * "unset", not "denied").
+ */
+export function inferMusicVideo(analysis: {
+  scenes?: ReadonlyArray<{ audio?: ReadonlyArray<{ mode?: string; content?: string }> }>
+} | undefined | null): boolean {
+  const scenes = analysis?.scenes ?? []
+  if (scenes.length < 4) return false
+  const musicLayers = (sc: (typeof scenes)[number]) => (sc.audio ?? []).filter((a) => a?.mode === "music")
+  const withMusic = scenes.filter((sc) => musicLayers(sc).length > 0).length
+  if (withMusic / scenes.length < 0.8) return false
+  return scenes.some((sc) =>
+    musicLayers(sc).some((a) => {
+      const content = typeof a.content === "string" ? a.content : ""
+      if (MUSIC_NO_VOCAL_RE.test(content)) return false
+      return MUSIC_VOCAL_RE.test(content) || MUSIC_VOCAL_QUOTE_RE.test(content)
+    }),
+  )
+}