@nodaro/shared 2.8.0 → 2.11.0

package/src/model-catalog.ts

@@ -886,6 +886,9 @@ const IMAGE_MODELS: Record<string, ModelCatalogEntry> = {
     description:
       "Grok Imagine Image 2.0 — expressive, high-contrast t2i. Generations chain into grok-2-segment (free named region masks) and grok-2-edit (region-targeted edits).",
     useCases: ["stylized", "expressive", "general"],
+    // Refs auto-route to grok-2-i2i (segment-map → image-edit chain); ONE
+    // reference (REF_IMAGE_MAX_LIMITS).
+    features: ["reference-image"],
     aspectRatios: GROK_RATIOS,
     pricing: [{ identifier: "grok-2", credits: 10 }],
   },
@@ -901,6 +904,22 @@ const IMAGE_MODELS: Record<string, ModelCatalogEntry> = {
     useCases: ["edit", "region-edit"],
     pricing: [{ identifier: "grok-2-edit", credits: 10 }],
   },
+  // Auto-selected when references are attached to grok-2 (T2I_TO_I2I_VARIANT):
+  // the t2i endpoint takes no image, so the FREE segment-map mints a task id
+  // from the reference URL and image-edit consumes it. Single reference.
+  "grok-2-i2i": {
+    id: "grok-2-i2i",
+    kind: "image",
+    modes: ["i2i"] as const,
+    family: "xAI",
+    label: "Grok Imagine 2 (reference)",
+    series: "Grok",
+    description:
+      "grok-2 guided by ONE reference image via the segment-map → image-edit chain — preserves the reference's composition while applying the prompt.",
+    useCases: ["restyle", "edit", "reference"],
+    features: ["reference-image"],
+    pricing: [{ identifier: "grok-2-i2i", credits: 10 }],
+  },
   "grok-2-segment": {
     id: "grok-2-segment",
     kind: "image",

package/src/model-constants.ts

@@ -5,7 +5,7 @@
 import { z } from "zod"
 import { MODEL_CATALOG } from "./model-catalog.js"
 
-/** Base USD cost per 1 Nodaro credit, at cost. Used for cost→credit conversion. */
+/** Base USD value of 1 Nodaro credit. Used for cost→credit conversion. */
 export const CREDIT_BASE_USD = 0.002
 
 /** Max characters for the (assembled) prompt accepted by the image-generation routes
@@ -232,16 +232,25 @@ export function getMaxTtsChars(provider: string | undefined): number {
  * Suno per-version field caps (from docs.kie.ai/suno-api/generate-music). The old
  * flat {@link SUNO_TEXT_MAX} (3000) was simultaneously too low for V4.5+/V5
  * prompts (5000) and too high for `style` (1000) and `title` (80).
- *   - prompt / lyrics: 500 in non-custom mode (all versions); in custom mode
+ *   - prompt / lyrics: 3000 in non-custom mode (all versions); in custom mode
  *     3000 for V4/V3.5 and 5000 for V4.5 / V4.5PLUS / V4.5ALL / V5 / V5.5.
  *   - style: 200 for V4/V3.5, 1000 for V4.5+.
  *   - title: 80 (all versions).
  */
 export const SUNO_TITLE_MAX = 80
 
-/** Max Suno `prompt` (= lyrics in custom mode) length for a model version. */
+/**
+ * Max Suno `prompt` (= lyrics in custom mode) length for a model version.
+ *
+ * NON-CUSTOM WAS 500 UNTIL 2026-08-19 — six times under the provider's
+ * documented 3000, and the route TRUNCATES to this number instead of
+ * rejecting, so everything past it vanished without a trace. Field evidence:
+ * a 950-character recast score brief (instruments, vocal, the source's own
+ * scat syllables, the arrangement's arc) reached Suno as exactly 500
+ * characters, cut mid-word.
+ */
 export function getMaxSunoPromptChars(model: string | undefined, customMode: boolean): number {
-  if (!customMode) return 500
+  if (!customMode) return 3000
   return model === "V4" || model === "V3_5" ? 3000 : 5000
 }
 
@@ -364,6 +373,7 @@ export const MODELS_WITH_REFERENCE_IMAGE_SUPPORT = new Set([
   "gpt-image",
   "gpt-image-2",
   "grok",
+  "grok-2",
   "qwen",
   "seedream",
   "seedream-5-lite",
@@ -374,6 +384,7 @@ export const MODELS_WITH_REFERENCE_IMAGE_SUPPORT = new Set([
   "nano-banana-edit",
   "gpt-image-i2i",
   "gpt-image-2-i2i",
+  "grok-2-i2i",
   "flux-i2i",
   "flux-pro-i2i",
   "flux-kontext",
@@ -412,6 +423,9 @@ export const T2I_TO_I2I_VARIANT: Record<string, string> = {
   "gpt-image": "gpt-image-i2i",
   "gpt-image-2": "gpt-image-2-i2i",
   "grok": "grok-i2i",
+  // grok-2's t2i takes NO image input; its "i2i" is the segment-map(image_url)
+  // → image-edit(task_id) chain in the KIE provider (single reference).
+  "grok-2": "grok-2-i2i",
   "qwen": "qwen-i2i",
   "seedream": "seedream-edit",
   "seedream-5-lite": "seedream-5-lite-i2i",
@@ -437,6 +451,8 @@ export const REF_IMAGE_MAX_LIMITS: Record<string, number> = {
   "nano-banana-2": 4,
   "nano-banana-2-lite": 10,
   "wan-2.7": 9,
+  // grok-2 reference chain consumes exactly one image (segment-map input).
+  "grok-2-i2i": 1,
   // Image-to-image (multi-source array)
   "nano-banana-edit": 8,
   "gpt-image-i2i": 16,
@@ -592,6 +608,7 @@ export const IMAGE_I2I_PROVIDERS = [
   "flux-pro-i2i",
   "gpt-image-i2i",
   "gpt-image-2-i2i",
+  "grok-2-i2i",
   "ideogram-edit",
   "ideogram-remix",
   "ideogram-reframe",
@@ -824,6 +841,35 @@ export function resolveVideoProviderForMode(
   return provider
 }
 
+/**
+ * Which execution mode a unified Generate Video run takes from what is wired.
+ * Shared by the frontend DAG executor (`execute-node.ts`) and the backend
+ * orchestrator (`payload-builder.ts`) so the two cannot disagree.
+ *
+ * A start frame is image-to-video, full stop. Reference images ALONE are the
+ * nuance: most models forward refs on either path, but a split-id model
+ * (VIDEO_MODE_ALIASES) can carry them on one twin only — Grok Imagine 1's
+ * text-to-video endpoint has no image parameter at all, while its i2v twin
+ * takes up to 7. Refs wired without a start frame used to resolve to t2v →
+ * `grok` → silently dropped (#861). When refs are present and ONLY the i2v
+ * twin can carry them, the run is image-to-video with the refs as its images.
+ * Derived from VIDEO_REF_LIMITS_BY_PROVIDER (= the catalog's `reference-image`
+ * feature), never from a provider name; single-id models are untouched
+ * because both twins are the same id.
+ */
+export function resolveVideoModeForInputs(
+  provider: string | undefined,
+  inputs: { readonly hasStartFrame: boolean; readonly hasImageRefs: boolean },
+): "image-to-video" | "text-to-video" {
+  if (inputs.hasStartFrame) return "image-to-video"
+  if (!provider || !inputs.hasImageRefs) return "text-to-video"
+  const i2v = resolveVideoProviderForMode(provider, "image-to-video")
+  const t2v = resolveVideoProviderForMode(provider, "text-to-video")
+  if (i2v === t2v) return "text-to-video"
+  const carriesImageRefs = (id: string) => (VIDEO_REF_LIMITS_BY_PROVIDER[id]?.images ?? 0) > 0
+  return carriesImageRefs(i2v) && !carriesImageRefs(t2v) ? "image-to-video" : "text-to-video"
+}
+
 /**
  * t2v twin ids hidden from the unified Generate Video picker — the i2v/base
  * entry already represents both modes (execution remaps by image presence).
@@ -1526,9 +1572,8 @@ export const SEEDANCE_2_R2V_MIN_REF_VIDEO_SEC = 1.8
  * credit formulas bill per continuation join. Clears the provider floor
  * above with margin while staying short enough to keep the model focused on
  * continuing the boundary motion instead of re-staging the whole clip.
- * Guarded ≥ floor by model-constants tests; the private-plugin twin
- * (nodaro-cloud-plugins chain.ts TAIL_SEC / bridge-math.ts MIN_REF) is
- * guarded by that repo's r2v-ref-floor.test.ts — keep the two in sync.
+ * Guarded ≥ floor by model-constants tests; the plugin repo carries a twin
+ * constant guarded by its own tests — keep the two in sync.
  */
 export const SEEDANCE_2_CONTINUATION_REF_SEC = 2
 

package/src/organizations/index.ts

@@ -0,0 +1,2 @@
+export * from "./types.js"
+export * from "./views.js"

package/src/organizations/types.ts

@@ -0,0 +1,152 @@
+import { z } from "zod"
+
+/**
+ * Organizations — wire contract for the second tenancy axis
+ * (Organization -> Workspace -> Member).
+ *
+ * Lives in @nodaro/shared because SDK/MCP consumers need these enums, the
+ * request schemas the API validates, and the error codes it returns. This
+ * package carries the CONTRACT ONLY — no resolution logic, no presets, no
+ * vocabulary, no access rule. Those are server-side.
+ */
+
+/**
+ * Selects which workspace a request LISTS from and CREATES into. It never
+ * authorizes: reading, updating, deleting or running an identified object is
+ * decided by that object's own workspace, so a forgotten or forged header can
+ * neither widen access nor move a charge.
+ *
+ * Fastify lower-cases incoming header keys, hence the second constant — read
+ * `req.headers[WORKSPACE_HEADER_LOWER]`, send `WORKSPACE_HEADER`.
+ */
+export const WORKSPACE_HEADER = "X-Nodaro-Workspace"
+export const WORKSPACE_HEADER_LOWER = "x-nodaro-workspace"
+
+export const ORG_KINDS = ["school", "team"] as const
+export type OrgKind = (typeof ORG_KINDS)[number]
+
+export const ORG_ROLES = ["owner", "admin", "member"] as const
+export type OrgRole = (typeof ORG_ROLES)[number]
+
+export const WORKSPACE_ROLES = ["admin", "member"] as const
+export type WorkspaceRole = (typeof WORKSPACE_ROLES)[number]
+
+export const MEMBER_STATUSES = ["active", "suspended"] as const
+export type MemberStatus = (typeof MEMBER_STATUSES)[number]
+
+/** `pending` = created, awaiting platform-admin approval. */
+export const ORG_STATUSES = ["pending", "active", "suspended", "deleted"] as const
+export type OrgStatus = (typeof ORG_STATUSES)[number]
+
+/** An explicit per-workflow grant (works for personal workflows too). */
+export const COLLABORATOR_ROLES = ["editor", "viewer"] as const
+export type CollaboratorRole = (typeof COLLABORATOR_ROLES)[number]
+
+export const WORKFLOW_VISIBILITIES = ["private", "workspace"] as const
+export type WorkflowVisibility = (typeof WORKFLOW_VISIBILITIES)[number]
+
+/** What an identity may do with a workflow, strongest first. */
+export const ACCESS_LEVELS = ["own", "edit", "view", "none"] as const
+export type AccessLevel = (typeof ACCESS_LEVELS)[number]
+
+/** The access a setting may grant to a non-creator. */
+export const GRANTED_ACCESS = ["view", "edit"] as const
+export type GrantedAccess = (typeof GRANTED_ACCESS)[number]
+
+export const SUBMISSION_STATUSES = ["submitted", "in_review", "returned", "approved"] as const
+export type SubmissionStatus = (typeof SUBMISSION_STATUSES)[number]
+
+/**
+ * Error codes the organization endpoints add to the standard envelope
+ * (`{ error: { code, message } }`). Clients dispatch on the code, never on
+ * the message text.
+ */
+export const ORG_ERROR_CODES = [
+  "not_a_member",
+  "insufficient_role",
+  "org_not_active",
+  "member_suspended",
+  "workspace_archived",
+  "personal_space_disabled",
+  "token_workspace_mismatch",
+  "run_requires_authenticated_member",
+  "budget_exceeded",
+  "member_cap_exceeded",
+  "model_not_allowed",
+  "invitation_expired",
+  "invitation_revoked",
+  "email_mismatch",
+  "join_code_invalid",
+  "domain_not_allowed",
+  "already_started",
+  "collab_unavailable",
+  // Organization, workspace and membership endpoints.
+  "terms_required",
+  "not_org_member",
+  "already_a_member",
+  "owner_cannot_leave",
+  "has_active_workspaces",
+  // Invitations and join codes.
+  "invitation_not_found",
+  "invitation_accepted",
+  "bulk_invite_cap_exceeded",
+] as const
+export type OrgErrorCode = (typeof ORG_ERROR_CODES)[number]
+
+/**
+ * The settings every organization kind has a default for. `organizations.
+ * settings` and `workspaces.settings` store PARTIAL overrides of this shape;
+ * `resolveEffectiveSettings` (./settings.ts) produces the full one.
+ */
+export const PresetSettingsSchema = z.object({
+  /** What org/workspace admins may do with a member's workflow. */
+  admin_access: z.enum(GRANTED_ACCESS),
+  default_workflow_visibility: z.enum(WORKFLOW_VISIBILITIES),
+  /** What a plain member may do with a `visibility = workspace` workflow. */
+  member_access_to_shared: z.enum(GRANTED_ACCESS),
+  members_can_create_projects: z.boolean(),
+  member_caps_enabled: z.boolean(),
+  /** Whether members keep a personal (non-workspace) space at all. */
+  personal_space_enabled: z.boolean(),
+  /** Whether a workspace admin may invite NEW people into the org. */
+  workspace_admins_can_invite: z.boolean(),
+  /** Whether an editor collaborator may invite further collaborators. */
+  collaborators_can_invite: z.boolean(),
+  /**
+   * When the organization is SUSPENDED, do its content rules still bind its
+   * members?
+   *
+   * Today this governs exactly one rule — `personal_space_enabled` — and that
+   * is not an accident: every other key above governs behaviour INSIDE a
+   * workspace, and a suspended organization grants no workspace context at
+   * all, so those are already moot.
+   *
+   * The name is general because an organization is deciding a principle here,
+   * not one checkbox's fate. Default `false`, which is today's behaviour: a
+   * suspended organization stops binding, and its members work independently
+   * until it resumes. An organization whose reason for disabling the personal
+   * space is contractual — the work made here belongs to the institution —
+   * turns this on, because an unpaid invoice does not void a contract.
+   */
+  policy_survives_suspension: z.boolean(),
+})
+export type PresetSettings = z.infer<typeof PresetSettingsSchema>
+export type PresetSettingKey = keyof PresetSettings
+export const PRESET_SETTING_KEYS = Object.freeze(
+  Object.keys(PresetSettingsSchema.shape) as readonly PresetSettingKey[],
+)
+
+/** `workspaces.settings` — per-workspace overrides only. */
+export const WorkspaceSettingsSchema = PresetSettingsSchema.partial()
+export type WorkspaceSettings = z.infer<typeof WorkspaceSettingsSchema>
+
+const EMAIL_DOMAIN_PATTERN = /^[a-z0-9-]+(\.[a-z0-9-]+)+$/
+
+/** `organizations.settings` — preset overrides plus org-only keys. */
+export const OrgSettingsSchema = PresetSettingsSchema.partial().extend({
+  /** Lower-case domains that join codes / domain auto-join accept. Empty = any. */
+  allowed_email_domains: z.array(z.string().regex(EMAIL_DOMAIN_PATTERN)).optional(),
+  /** Per-org relabelling of the kind vocabulary (./vocabulary.ts). */
+  vocabulary_overrides: z.record(z.string(), z.string()).optional(),
+})
+export type OrgSettings = z.infer<typeof OrgSettingsSchema>

package/src/organizations/views.ts

@@ -0,0 +1,220 @@
+import type {
+  MemberStatus,
+  OrgKind,
+  OrgRole,
+  OrgSettings,
+  OrgStatus,
+  WorkspaceRole,
+  WorkspaceSettings,
+} from "./types.js"
+
+/**
+ * What the organization endpoints RETURN.
+ *
+ * `types.ts` carries what a client must send and the codes it must dispatch
+ * on; this carries the other half of the same wire contract — the shapes that
+ * come back. It lives here for the same reason: the SDK, the CLI, the app and
+ * any third-party integration all read these, and a shape described in three
+ * places is a shape that drifts in two of them.
+ *
+ * CONTRACT ONLY, like its sibling. There is no resolution logic here, no
+ * access rule, no vocabulary — a view names fields, it does not decide who
+ * may see them. Fields the server omits for a caller without the standing to
+ * see them are OPTIONAL here rather than nullable: absent means "not for
+ * you", `null` means "genuinely unset", and a client that cannot tell those
+ * apart will render the wrong thing.
+ */
+
+export interface OrganizationView {
+  id: string
+  slug: string
+  name: string
+  kind: OrgKind
+  status: OrgStatus
+  ownerUserId: string
+  settings: OrgSettings
+  termsAcceptedAt: string | null
+  createdAt: string
+  updatedAt: string
+  /** The CALLER's role. Absent on a read that did not establish membership. */
+  role?: OrgRole
+  memberStatus?: MemberStatus
+}
+
+export interface OrgMemberView {
+  userId: string
+  role: OrgRole
+  status: MemberStatus
+  joinedAt: string
+  email: string | null
+  displayName: string | null
+  avatarUrl: string | null
+}
+
+export interface WorkspaceView {
+  id: string
+  orgId: string
+  name: string
+  slug: string
+  description: string | null
+  settings: WorkspaceSettings
+  defaultProjectId: string | null
+  archived: boolean
+  archivedAt: string | null
+  createdAt: string
+  updatedAt: string
+  /** The CALLER's role. Absent on a read that did not establish membership. */
+  role?: WorkspaceRole
+  memberStatus?: MemberStatus
+}
+
+export interface WorkspaceMemberView {
+  userId: string
+  role: WorkspaceRole
+  displayName: string | null
+  avatarUrl: string | null
+  addedAt: string
+  /** Workspace admins only — absent for a plain member's read. */
+  status?: MemberStatus
+  creditCap?: number | null
+}
+
+/** Where an invitation stands. `expired` is derived from `expiresAt`, not stored. */
+export type InvitationState = "open" | "accepted" | "revoked" | "expired"
+
+export interface InvitationView {
+  id: string
+  orgId: string
+  workspaceId: string | null
+  email: string
+  orgRole: OrgRole
+  workspaceRole: WorkspaceRole | null
+  invitedBy: string | null
+  state: InvitationState
+  expiresAt: string
+  acceptedAt: string | null
+  revokedAt: string | null
+  createdAt: string
+}
+
+/**
+ * One row per address a create/resend was asked for.
+ *
+ * `link` is present whenever the address was NOT emailed — an install with no
+ * mail provider, or a delivery that failed. A client MUST surface it: the
+ * invitation exists either way, and without the link nobody can reach it.
+ */
+export interface InvitationDelivery {
+  email: string
+  status: "sent" | "link_only" | "failed"
+  link?: string
+}
+
+/**
+ * What an invitee sees BEFORE signing in — the one organization read that
+ * needs no token. `email` comes back masked, so the invitee can recognise
+ * their own address without the link disclosing it to whoever holds it.
+ */
+export interface InvitationPreview {
+  orgName: string
+  kind: OrgKind
+  vocabulary: Record<string, string>
+  inviterName: string | null
+  workspaceName: string | null
+  email: string
+  expiresAt: string
+  state: InvitationState
+}
+
+export interface JoinCodeView {
+  code: string
+  enabled: boolean
+  rotatedAt: string
+  rotatedBy: string | null
+}
+
+/**
+ * What `GET /v1/me` reports about the caller's memberships.
+ *
+ * Deliberately a SUMMARY, not the full views above: this is the payload every
+ * client loads on every session start, and it answers one question — what am
+ * I a member of, and what may I call each thing. Names, roles, and the
+ * resolved vocabulary are here because a switcher cannot render without them;
+ * descriptions, timestamps and default projects are not, because a switcher
+ * never shows them and `GET /v1/orgs/:id` exists.
+ *
+ * The settings block is narrowed to the three keys a CLIENT can act on. The
+ * rest of an organization's settings are enforced server-side, and shipping
+ * them here would invite a client to enforce them badly.
+ */
+export interface OrganizationSummary {
+  id: string
+  slug: string
+  name: string
+  kind: OrgKind
+  status: OrgStatus
+  /** The caller's own role and standing — always present in this payload. */
+  role: OrgRole
+  memberStatus: MemberStatus
+  settings: {
+    personal_space_enabled: boolean
+    allowed_email_domains: string[]
+    vocabulary_overrides: Record<string, string>
+  }
+  /** Resolved labels, so no client hard-codes "Class" or "Team". */
+  vocabulary: Record<string, string>
+}
+
+export interface WorkspaceSummary {
+  id: string
+  orgId: string
+  name: string
+  slug: string
+  role: WorkspaceRole
+  memberStatus: MemberStatus
+  archived: boolean
+}
+
+/**
+ * The organizations block on `GET /v1/me`.
+ *
+ * THREE distinct states, and a client that collapses them is wrong in a way
+ * users feel: the fields ABSENT means this install has no organizations at
+ * all; present and empty means the account belongs to none; and
+ * `organizationsUnavailable` means the lookup FAILED — in which case a
+ * client must KEEP whatever selection it already had, because telling someone
+ * their school vanished during a cache blip is worse than a stale switcher.
+ */
+export interface MeOrganizations {
+  organizations?: OrganizationSummary[]
+  workspaces?: WorkspaceSummary[]
+  lastWorkspaceId?: string | null
+  organizationsUnavailable?: boolean
+}
+
+/**
+ * One recorded action in an organization's audit log.
+ *
+ * `action` is an OPEN vocabulary and a client must not exhaust it: new
+ * actions are added as the product grows, and a switch that throws on an
+ * unknown one turns a new feature into a broken page. Render what you
+ * recognise, fall back to the raw string for the rest.
+ *
+ * `actor` is null for anything the system did on nobody's behalf.
+ */
+export interface OrgAuditEntry {
+  id: string
+  workspaceId: string | null
+  action: string
+  targetType: string | null
+  targetId: string | null
+  details: Record<string, unknown>
+  createdAt: string
+  actor: { userId: string; displayName: string | null; email: string | null } | null
+}
+
+/** A cursor-paged read. The cursor is part of the answer, not a side channel. */
+export interface OrgPage<T> {
+  data: T[]
+  nextCursor: string | null
+}

package/src/parameter-node-value.ts

@@ -77,6 +77,17 @@ export const HINT_EXEMPT_PARAMETER_TYPES: ReadonlySet<string> = new Set([
   "aspect-ratio",
 ])
 
+/**
+ * Extra person-dimension data-field names contributed by registered person
+ * packs. Content-free (field-name strings only) — populated at runtime by
+ * `@nodaro/prompts`'s `registerPersonPack`; empty on mainline (identity).
+ * shared MUST NOT import prompts, so the field list is pushed in, not pulled.
+ */
+let registeredPersonPackFields: readonly string[] = []
+export function setRegisteredPersonPackFields(fields: readonly string[]): void {
+  registeredPersonPackFields = [...fields]
+}
+
 export function getParameterValue(
   data: Record<string, unknown>,
   nodeType: string,
@@ -171,11 +182,11 @@ export function getParameterValue(
       return trim(data.backdrop)
     case "held-prop":
       return trim(data.heldProp)
-    case "person":
+    case "person": {
       // Multi-dimension: return the first set per-dimension value (used for
       // single-string field-mapping resolution; full hint composition goes
       // through buildPersonHints in the executors).
-      return (
+      const base =
         trim(data.type) ??
         trim(data.age) ??
         trim(data.ethnicity) ??
@@ -210,7 +221,16 @@ export function getParameterValue(
         trim(data.distinctiveFeature) ??
         trim(data.lipState) ??
         trim(data.eyeState)
-      )
+      if (base !== undefined) return base
+      // Fall back to any registered person-pack dimension field (G4): a
+      // deployment overlay's extra person dimensions resolve in the
+      // `{PersonLabel}` field-mapping single-string path. Empty on mainline.
+      for (const field of registeredPersonPackFields) {
+        const v = trim(data[field])
+        if (v !== undefined) return v
+      }
+      return undefined
+    }
     case "mood":
       return trim(data.mood)
     case "photographer":

package/src/producer-types.ts

@@ -79,6 +79,16 @@ export const VIDEO_PRODUCER_TYPES: ReadonlySet<string> = new Set([
   "cinematic-avatar",
   // Assemble Narrated Video: fits N (clip, voice) blocks into one MP4 → video.
   "assemble-narrated-video",
+  // Still to Video: one still image + one audio track → MP4 (local FFmpeg,
+  // no provider). Emits generatedVideoUrl like every other ffmpeg video node.
+  "still-to-video",
+  // Slideshow: 2-100 stills + one optional audio track → MP4 (local FFmpeg,
+  // no provider). Same contract; images arrive via the image-collage lane.
+  "slideshow",
+  // GIF to Video: animated GIF → H.264 MP4 (local FFmpeg, no provider).
+  // Emits generatedVideoUrl so it connects to any downstream video consumer
+  // (e.g. a Seedance video-reference input) by an ordinary edge.
+  "gif-to-video",
 ])
 
 /**

package/src/smart-cut-windows.ts

@@ -1,19 +1,12 @@
 /**
- * Smart-cut best-pair SEARCH WINDOWS — the shared bound + clamp for
+ * Smart-cut SEARCH WINDOWS — the shared bound + clamp for
  * generate-video-pro's `smartCutFramesPrev` / `smartCutFramesNext`.
  *
- * What they do: the best-pair matcher (the mode the node calls "legacy-8x8")
- * PSNR-compares the last N frames of a segment against the first M of the
- * next, ends the previous clip ON the best match and starts the next right
- * AFTER its twin — so the duplicated frame plays once and motion stays
- * continuous. N and M are those windows. Absent → the engine's own 8/8
- * default, which is byte-identical to the behavior before they were
- * exposed.
- *
- * Why wider helps: a continuation can re-enact a longer stretch of the
- * previous tail than 8 frames covers, and a match outside the window is
- * simply never found — the boundary silently falls back to the fixed
- * freeze-trims. recast pins 24/24 for exactly this reason.
+ * They bound how much of each side of a boundary the engine considers when
+ * it places the cut: N frames from the end of a segment and M from the start
+ * of the next. Absent → the engine's own default, byte-identical to the
+ * behavior before they were exposed. A boundary the engine cannot resolve
+ * inside the window falls back to the fixed freeze-trims; recast pins 24/24.
  *
  * Why a shared clamp: the canvas node (single-node Run) and the orchestrator
  * (workflow Run) are two independent send paths into the same engine route,
@@ -23,10 +16,8 @@
  * and the two paths cannot drift apart.
  */
 
-/** Widest window the UI offers. The engine route itself accepts up to 48;
- *  24 is the product cap — it already covers a full second of re-enactment
- *  at 24fps, and every frame added past the real overlap only costs match
- *  time and invites a spurious pairing. */
+/** Widest window the UI offers (the engine route itself accepts up to 48).
+ *  Past this, added frames only cost search time and invite a false match. */
 export const SMART_CUT_WINDOW_MAX = 24
 /** Narrowest meaningful window — one frame each side. */
 export const SMART_CUT_WINDOW_MIN = 1

package/src/suno-track-sources.ts

@@ -0,0 +1,23 @@
+/**
+ * Node types whose output carries Suno chaining ids (`sunoTrackId` /
+ * `sunoTaskId`) for a downstream Suno node (extend / separate / replace /
+ * add-vocals / …) to chain off.
+ *
+ * One set for the three readers — the canvas resolver, the orchestrator
+ * resolver, and the config panels' "Inherited" hint (#819). They used to keep
+ * their own copies and drifted: the canvas read ids off a `suno-separate`
+ * (whose output is stems, not a track) while the orchestrator ignored it, so
+ * the same graph resolved on one path and not the other. Structural
+ * vocabulary only — node type names, no prompt content.
+ */
+export const SUNO_TRACK_SOURCE_TYPES: ReadonlySet<string> = new Set([
+  "suno-generate",
+  "suno-cover",
+  "suno-extend",
+  "suno-mashup",
+  "suno-replace-section",
+  "suno-add-instrumental",
+  "suno-add-vocals",
+  "suno-convert-wav",
+  "suno-upload-extend",
+])