@nodaro/shared 3.11.0 → 3.12.0

package/src/model-constants.ts

@@ -4,6 +4,7 @@
  */
 import { z } from "zod"
 import { MODEL_CATALOG } from "./model-catalog.js"
+import { isAutoVideoDuration, VIDEO_DURATION_AUTO } from "./video-duration-auto.js"
 
 /** Base USD value of 1 Nodaro credit. Used for cost→credit conversion. */
 export const CREDIT_BASE_USD = 0.002
@@ -1042,6 +1043,41 @@ export const VIDEO_TO_VIDEO_PROVIDERS = [
 ] as const
 export type VideoToVideoProvider = typeof VIDEO_TO_VIDEO_PROVIDERS[number]
 
+/**
+ * Seedance models the Video to Video NODE offers as a whole-clip, prompt-driven
+ * EDIT ("make it black and white", "she wears @image_1").
+ *
+ * These are deliberately NOT members of {@link VIDEO_TO_VIDEO_PROVIDERS} (the
+ * `/v1/video-to-video` route's own enum): Seedance has no separate edit
+ * endpoint — it edits a REFERENCE video when the prompt reads as an edit. So
+ * every surface (single-node run, DAG payload builder, MCP `modify_video`)
+ * dispatches these through the ONE existing Seedance reference-video lane
+ * (`text-to-video`), with the source clip as `@video_1` and the edit shape
+ * below. Reference-clip bounds, the unit×(input+output) reservation, the
+ * measured settlement, the edit-mode retry and the reconcile recovery are that
+ * lane's — there is no second copy to keep in step.
+ */
+export const SEEDANCE_VIDEO_EDIT_PROVIDERS = ["seedance-2-5"] as const
+export type SeedanceVideoEditProvider = typeof SEEDANCE_VIDEO_EDIT_PROVIDERS[number]
+
+export function isSeedanceVideoEditProvider(provider: string | undefined): provider is SeedanceVideoEditProvider {
+  return !!provider && (SEEDANCE_VIDEO_EDIT_PROVIDERS as readonly string[]).includes(provider)
+}
+
+/** Every model the Video to Video node can be set to: the route's own providers
+ *  plus the Seedance edit models dispatched through the text-to-video lane. */
+export const VIDEO_TO_VIDEO_NODE_PROVIDERS = [...VIDEO_TO_VIDEO_PROVIDERS, ...SEEDANCE_VIDEO_EDIT_PROVIDERS] as const
+export type VideoToVideoNodeProvider = typeof VIDEO_TO_VIDEO_NODE_PROVIDERS[number]
+
+/**
+ * The request shape Seedance edit mode requires, sent UP FRONT by the Video to
+ * Video node: the output takes the source clip's own ratio and length
+ * (`adaptive`, and Auto = `VIDEO_DURATION_AUTO`). Camel-cased twin of the KIE
+ * wire pair the provider layer resubmits with when Seedance reclassifies an
+ * ordinary run as an edit.
+ */
+export const SEEDANCE_VIDEO_EDIT_SHAPE = { aspectRatio: "adaptive", duration: VIDEO_DURATION_AUTO } as const
+
 /** Face swap providers */
 export const FACE_SWAP_PROVIDERS = [
   "roop",
@@ -1208,15 +1244,97 @@ export const MUSIC_PROVIDERS = [
 ] as const
 export type MusicProvider = typeof MUSIC_PROVIDERS[number]
 
-/** Transcription providers */
+/**
+ * Transcription providers a caller may name — on `/v1/transcribe`, the SDK/CLI
+ * and the canvas Transcribe node. All three lanes are served on cloud again
+ * (the canvas picker re-offered the two Replicate lanes in #768 while this enum
+ * still hid them, so a single-node Run on Whisper 400'd where the same node in a
+ * workflow Run worked). `elevenlabs-stt` stays FIRST: several call sites take
+ * "the first enabled word-capable provider" from this order.
+ */
 export const TRANSCRIBE_PROVIDERS = [
-  // Replicate disabled
-  // "whisper",
-  // "incredibly-fast-whisper",
   "elevenlabs-stt",
+  "whisper",
+  "incredibly-fast-whisper",
 ] as const
 export type TranscribeProvider = typeof TRANSCRIBE_PROVIDERS[number]
 
+/**
+ * Every transcription LANE the platform implements. Today this is the same set
+ * as `TRANSCRIBE_PROVIDERS`; it stays a separate name because the two answer
+ * different questions — "what may a caller name" vs "what can run" — and they
+ * have diverged before (the Replicate lanes were hidden from callers for months
+ * while still reached at runtime via the route default and add-captions'
+ * auto-transcribe). Capability questions must be asked over THIS union.
+ */
+export const TRANSCRIBE_LANES = [
+  "whisper",
+  "incredibly-fast-whisper",
+  "elevenlabs-stt",
+] as const
+export type TranscribeLane = typeof TRANSCRIBE_LANES[number]
+
+// Compile-time pin: the user-facing enum is a subset of the lanes, so every
+// provider a caller can name has a capability row below.
+const _TRANSCRIBE_PROVIDERS_ARE_LANES: readonly TranscribeLane[] = TRANSCRIBE_PROVIDERS
+void _TRANSCRIBE_PROVIDERS_ARE_LANES
+
+/**
+ * What each transcription lane can actually DO. Single source of truth — never
+ * re-derive a capability from a provider-name check.
+ *
+ * `wordTimestamps`: does the lane return per-word start/end times?
+ *  - `whisper` (Replicate `openai/whisper`) — NO. Its input schema has no
+ *    `word_timestamps` field in ANY published version, so Replicate silently
+ *    drops the key and the segments come back without `words`. Asking this lane
+ *    for word timings yields an empty array, never an error.
+ *  - `incredibly-fast-whisper` — yes, via `timestamp: "word"`.
+ *  - `elevenlabs-stt` (direct Scribe) — always word-level, flag or not.
+ */
+export const TRANSCRIBE_PROVIDER_CAPABILITIES: Record<TranscribeLane, { wordTimestamps: boolean }> = {
+  "whisper": { wordTimestamps: false },
+  "incredibly-fast-whisper": { wordTimestamps: true },
+  "elevenlabs-stt": { wordTimestamps: true },
+}
+
+/** The lanes that can honour a word-timestamps request, in declaration order. */
+export function transcribeProvidersWithWordTimestamps(): TranscribeLane[] {
+  return TRANSCRIBE_LANES.filter((p) => TRANSCRIBE_PROVIDER_CAPABILITIES[p].wordTimestamps)
+}
+
+/**
+ * Capability question for a lane id that came from UNTRUSTED data — node data,
+ * an imported workflow, a wire body — where the string may be anything at all.
+ * An unknown lane answers `false`: we cannot promise word timings from a lane
+ * we know nothing about, and "false" is always the safe answer (it suppresses
+ * an INFERRED request, and turns an EXPLICIT one into the honest refusal in
+ * `transcribe()` instead of a `Cannot read properties of undefined` TypeError).
+ */
+export function transcribeLaneSupportsWordTimestamps(lane: string | null | undefined): boolean {
+  if (!lane) return false
+  return TRANSCRIBE_PROVIDER_CAPABILITIES[lane as TranscribeLane]?.wordTimestamps === true
+}
+
+/**
+ * The lane an absent `provider` resolves to — the historical `/v1/transcribe`
+ * default, kept as-is because the credit guard reserves on the provider id
+ * (changing it would silently change what bills).
+ */
+export const DEFAULT_TRANSCRIBE_PROVIDER: TranscribeLane = "whisper"
+
+/**
+ * The lane a transcribe NODE with no `provider` in its data resolves to —
+ * deliberately NOT `DEFAULT_TRANSCRIBE_PROVIDER`. The route's default is the
+ * legacy whisper lane and exists only so a pre-existing REST caller keeps
+ * billing the same id; a node authored/imported without a provider is a fresh
+ * request, and the canvas picker's own default is this one. Single-sourced so
+ * the backend DAG (`payload-builder.ts`) and the frontend run
+ * (`execute-node.ts`) cannot drift into sending different engines for the same
+ * node — they did, and the frontend's silent whisper fallback started 400ing
+ * once the Replicate lanes left `TRANSCRIBE_PROVIDERS`.
+ */
+export const DEFAULT_TRANSCRIBE_NODE_PROVIDER: TranscribeLane = "elevenlabs-stt"
+
 /** Script generation providers */
 export const SCRIPT_PROVIDERS = [
   "gemini",
@@ -2551,7 +2669,32 @@ export const PRICING_DEFAULT_DURATION_SEC: Record<string, number> = {
 export function pricedOutputDurationSec(provider: string, requested: number | string | undefined): number {
   const fallback = PRICING_DEFAULT_DURATION_SEC[provider] ?? 5
   const parsed = typeof requested === "string" ? parseInt(requested, 10) : requested
-  return parsed === undefined || Number.isNaN(parsed) ? fallback : parsed
+  if (parsed === undefined || Number.isNaN(parsed)) return fallback
+  // AUTO (`VIDEO_DURATION_AUTO`): the model picks the length, so the only
+  // safe price is the LONGEST it can render — `commit_credits` refunds a surplus
+  // but never collects a deficit, and the delivered clip is measured at settle
+  // time (lib/seedance2-ref-video-settle.ts). Living HERE, the one source every
+  // tier and every scaled reservation reads, a new pricing call site reserves
+  // the ceiling by default instead of having to remember to. Any other
+  // non-positive value is nonsense and prices at the render default.
+  if (parsed <= 0) {
+    return isAutoVideoDuration(parsed) && supportsAutoVideoDuration(provider)
+      ? maxVideoDurationSec(provider) ?? fallback
+      : fallback
+  }
+  return parsed
+}
+
+/** Models that accept `VIDEO_DURATION_AUTO` — a catalog capability (docs.kie.ai:
+ *  the Seedance 2 family, "4-15 seconds or -1" / 2.5 "Special values -1"). */
+export function supportsAutoVideoDuration(provider: string | undefined): boolean {
+  return !!provider && MODEL_CATALOG[provider]?.autoDuration === true
+}
+
+/** The longest clip a duration-tiered provider can render (its top priced tier). */
+export function maxVideoDurationSec(provider: string): number | undefined {
+  const tiers = VIDEO_DURATION_TIERS[provider]
+  return tiers && tiers.length > 0 ? tiers[tiers.length - 1]!.maxSeconds : undefined
 }
 
 /**

package/src/node-mappable-fields.ts

@@ -69,6 +69,8 @@ export const NODE_MAPPABLE_FIELDS: Readonly<Record<string, readonly string[]>> =
   "creature":            ["creatureName", "description"],
   "location":            ["locationName", "description"],
   "web-scrape":          ["query", "url", "target"],
+  "meta-ads-scrape":     ["query", "pageUrls"],
+  "instagram-scrape":    ["targets"],
 }
 
 /** suno-generate secondary text fields exposed as `field-<key>` canvas handles. */

package/src/node-runtime-keys.ts

@@ -41,6 +41,9 @@ export const EXECUTION_DATA_KEYS: ReadonlySet<string> = new Set([
   "__listTotal",
   "__listCompleted",
   "__listResults",
+  // Row-aligned twin of __listResults (Extract Field, List output) — read only
+  // by the fan-out so two lists cut from one array pair by row.
+  "__alignedListResults",
   // List fan-out window flag (abandon-guard exemption). Set/cleared by
   // executeNodeForList — purely execution-related, never user-edited.
   "__listRunning",
@@ -70,6 +73,25 @@ export const EXECUTION_DATA_KEYS: ReadonlySet<string> = new Set([
   "lastInputs",
   "lastMeta",
   "__upstreamCount",
+  // Video URL node — the download's live percent/phase, written on every
+  // progress tick (~2/s). Pure run-state; also in TRANSIENT_RUNTIME_KEYS below.
+  "downloadPercent",
+  "downloadPhase",
+  // Webhook Output's delivery receipt. A webhook target may reflect the
+  // request back (httpbin, RequestBin, an API that 400s with "headers
+  // received: …"), so `webhookResponseBody` can carry whatever the request
+  // carried — with an attached credential, the secret itself. Listing the three
+  // here is what keeps the receipt out of template exports (GENERATED_FIELDS
+  // derives from this set), out of node presets, and out of undo history.
+  "webhookSuccess",
+  "webhookStatusCode",
+  "webhookResponseBody",
+  // When the editor's "Clear results" last emptied this node (ISO time). Not a
+  // result and not config: bookkeeping that tells the load-time recovery lanes
+  // "this node is empty ON PURPOSE" — without it, every reload reads an empty
+  // node as "ran while the editor was closed" and paints the last run back.
+  // Persisted (never transient): the reload is exactly when it is read.
+  "resultsClearedAt",
 ])
 
 /**
@@ -100,6 +122,12 @@ export const TRANSIENT_RUNTIME_KEYS: ReadonlySet<string> = new Set([
   "__listRunning",
   "_upstreamRefresh",
   "__upstreamCount",
+  // Video URL node download ticks. They used to dirty the workflow twice a
+  // second for the length of the download — the same phantom-save chain the
+  // job-progress keys above were moved here to stop. What SURVIVES a reload is
+  // `downloadStatus` + `downloadId`; the percent is re-read from the server.
+  "downloadPercent",
+  "downloadPhase",
 ])
 
 /**

package/src/presentation-utils.ts

@@ -145,6 +145,13 @@ const VIDEO_OUTPUT_TYPES = new Set([
   "upload-video",
   "lip-sync", "motion-transfer", "video-upscale", "add-captions",
   "social-media-format",
+  // apply-edl renders an EDL into video OR audio. Its medium is decided at run
+  // time (DYNAMIC_PRODUCER_TYPES), so getOutputType would answer "data" and a
+  // published app would render the cut as a JSON blob. Declaring it here — as
+  // the voice-changer/dubbing precedent does for their default medium — makes
+  // the classifier answer "video" (the common case; an audio-only cut still
+  // plays in a video element). Asserted in producer-types.test.ts.
+  "apply-edl",
 ])
 
 const AUDIO_OUTPUT_TYPES = new Set([
@@ -393,6 +400,48 @@ export function getInputFieldSchema(nodeType: string): InputFieldSchema | undefi
   return INPUT_FIELD_MAP[nodeType]
 }
 
+const MEDIA_INPUT_FIELD_TYPES: ReadonlySet<InputFieldSchema["type"]> = new Set([
+  "image-url",
+  "video-url",
+  "audio-url",
+])
+
+/**
+ * Shallow-merge run-time input overrides (a published app's inputs, an API-token
+ * run, MCP `run_app` / `run_workflow` inputs, a wired component handle) over a
+ * node's SAVED data — the one merge every such lane must use.
+ *
+ * `metadata` holds facts measured FROM the node's media (its length, its
+ * dimensions). When an override swaps that media — the node's primary input
+ * field is a media url (`INPUT_FIELD_MAP`) and the override changes it — the
+ * snapshot's facts describe a file that is no longer there, so they are dropped
+ * unless the override supplies its own. Left behind, a publisher's
+ * `metadata.durationSeconds` outranks the run's own transcript as Edit Plan's
+ * duration basis and under-buckets a caller's longer episode: an estimate that
+ * passes the balance precheck for a run the reserve then refuses.
+ *
+ * Schema-driven on purpose: a new media input node is covered by its
+ * `INPUT_FIELD_MAP` row, with no list to remember here.
+ */
+export function mergeNodeInputOverrides(
+  nodeType: string | undefined,
+  data: Record<string, unknown>,
+  overrides: Record<string, unknown>,
+): Record<string, unknown> {
+  const merged: Record<string, unknown> = { ...data, ...overrides }
+  const schema = nodeType ? INPUT_FIELD_MAP[nodeType] : undefined
+  if (
+    schema &&
+    MEDIA_INPUT_FIELD_TYPES.has(schema.type) &&
+    schema.key in overrides &&
+    overrides[schema.key] !== data[schema.key] &&
+    !("metadata" in overrides)
+  ) {
+    delete merged.metadata
+  }
+  return merged
+}
+
 // ---------------------------------------------------------------------------
 // Migration & validation helpers (PresentationItem)
 // ---------------------------------------------------------------------------

package/src/producer-types.ts

@@ -150,6 +150,19 @@ export const DYNAMIC_PRODUCER_TYPES: ReadonlySet<string> = new Set([
   // backend routes the correct lane by sourceHandle in getPrimaryOutput
   // (output-extractor.ts); the frontend does so in extractNodeOutput.
   "split-media",
+  // apply-edl renders an EDL into ONE media output whose type is decided at
+  // run time by the node's `output` setting (video OR audio) — so its static
+  // medium is genuinely unknown and it belongs here, letting canvas validators
+  // accept its default media handle on BOTH audio and video input handles. It
+  // ALSO emits a fixed `json` handle (the remapped Transcript); that half lives
+  // in JSON_PRODUCER_TYPES (frontend/src/lib/data-handles.ts). The FIRST node
+  // with both a dynamic media handle and a fixed json handle. Because
+  // getOutputType (presentation-utils.ts) deliberately returns "data" for
+  // DYNAMIC members, apply-edl is ALSO added to the literal VIDEO_OUTPUT_TYPES
+  // there so a published app renders the cut as video, mirroring the
+  // voice-changer/dubbing precedent. Asserted in producer-types.test.ts (the
+  // suite does not fail on omission).
+  "apply-edl",
 ])
 
 /**
@@ -216,4 +229,11 @@ export const FAN_OUT_EACH_TYPES: ReadonlySet<string> = new Set([
   "merge-lists",
   "sort-list",
   "selector",
+  // edit-plan `clips` mode emits a bare `Edl[]` on `data.generatedJson`, so an
+  // edge leaving it defaults to "each" — one downstream execution (typically an
+  // apply-edl render) per clip. The `tighten`/`chapters` modes emit an OBJECT,
+  // for which the list extractors return undefined, so an "each" edge falls back
+  // to the scalar `edl` value (no fan-out) — the same graceful degradation
+  // web-scrape relies on. See `unwrapEditPlanOutput` in `edit-plan-contract.ts`.
+  "edit-plan",
 ])