@crievo/omni 0.0.0-stage → 0.1.1

package/studio/web/lib/calendar.ts

@@ -0,0 +1,218 @@
+/* Schedule page helpers: the scheduled publications of every video (publication.json `schedule`,
+   written by `publish.mjs schedule`) and the ones already up (on the day and time they were
+   published), as calendar posts; dates in this Mac's time; drag to reschedule; and picking a
+   day for a publish draft (lib/publish-draft.ts). */
+
+import { createContext, useState, type DragEvent } from "react";
+import { mediaUrl } from "./media";
+import { platformName, type PlatformId } from "./platforms";
+import type { PublishDraft } from "./publish-draft";
+import type { ScheduledPost, VideoSummary } from "../types/api";
+
+export type CalendarView = "month" | "week" | "day";
+export const VIEWS: [CalendarView, string][] = [
+  ["month", "Mês"],
+  ["week", "Semana"],
+  ["day", "Dia"],
+];
+
+export type Post = {
+  /* a video can have the published post and a new schedule: the key tells them apart */
+  key: string;
+  slug: string;
+  title: string;
+  when: Date;
+  platforms: PlatformId[];
+  state: ScheduledPost["state"] | "published";
+  error: string | null;
+  img: string | null;
+  portrait: boolean;
+  /* comes from the schedule (drags and reschedules); the published one stays where it went up */
+  scheduled: boolean;
+};
+
+export const STATE_LABEL: Record<Post["state"], string> = {
+  scheduled: "Agendado",
+  publishing: "Publicando agora",
+  failed: "Falhou",
+  missed: "Perdeu a hora",
+  published: "Publicado",
+};
+const PLATFORM_IDS: PlatformId[] = ["youtube", "instagram", "tiktok"];
+
+/* what already went up: one post on the day and time of the first publication, with the platforms
+   where it is live; a platform that failed later (or never went up) leaves the post with an error.
+   A failure with nothing live, with a schedule, already shows on the schedule's post */
+export function publishedPostsOf(v: VideoSummary): Post[] {
+  const pub = v.publication;
+  if (!pub) return [];
+  const done = PLATFORM_IDS.filter(k => pub[k]?.published_at);
+  const failed = PLATFORM_IDS.filter(k => {
+    const p = pub[k];
+    return !!p?.last_error && (!p.published_at || p.last_error.at > p.published_at);
+  });
+  if (!done.length && (!failed.length || pub.schedule)) return [];
+  const when = done.length
+    ? done.map(k => pub[k]!.published_at!).sort()[0]
+    : failed
+        .map(k => pub[k]!.last_error!.at)
+        .sort()
+        .at(-1)!;
+  return [
+    {
+      key: `${v.slug}:published`,
+      slug: v.slug,
+      title: v.title,
+      when: new Date(when),
+      platforms: [...done, ...failed.filter(k => !done.includes(k))],
+      state: failed.length ? "failed" : "published",
+      error: failed.length ? failed.map(k => `${platformName(k)}: ${pub[k]!.last_error!.message}`).join(" · ") : null,
+      img: mediaUrl(v, v.thumbnail ?? v.cover),
+      portrait: !!v.format && v.format.h > v.format.w,
+      scheduled: false,
+    },
+  ];
+}
+
+/* `moved`: the new time while publication.json has not come back with it */
+export function postsOf(videos: VideoSummary[], moved: Record<string, Date>): Post[] {
+  return videos
+    .flatMap(v => {
+      const s = v.publication?.schedule;
+      if (!s) return publishedPostsOf(v);
+      return [
+        ...publishedPostsOf(v),
+        {
+          key: `${v.slug}:scheduled`,
+          scheduled: true,
+          slug: v.slug,
+          title: v.title,
+          when: moved[v.slug] ?? new Date(s.when),
+          platforms: s.platforms as PlatformId[],
+          state: (moved[v.slug] ? "scheduled" : s.state) as Post["state"],
+          error: moved[v.slug] ? null : (s.last_error?.message ?? null),
+          img: mediaUrl(v, v.thumbnail ?? v.cover),
+          portrait: !!v.format && v.format.h > v.format.w,
+        },
+      ];
+    })
+    .sort((a, b) => a.when.getTime() - b.when.getTime());
+}
+
+/* --- dates (this Mac's time, the same as the scheduler's) ---------------------------------- */
+export const startOfDay = (d: Date) => new Date(d.getFullYear(), d.getMonth(), d.getDate());
+export const addDays = (d: Date, n: number) => new Date(d.getFullYear(), d.getMonth(), d.getDate() + n);
+export const sameDay = (a: Date, b: Date) =>
+  a.getFullYear() === b.getFullYear() && a.getMonth() === b.getMonth() && a.getDate() === b.getDate();
+export const startOfWeek = (d: Date) => addDays(startOfDay(d), -d.getDay());
+export const hourOf = (d: Date) => d.toLocaleTimeString("pt-BR", { hour: "2-digit", minute: "2-digit" });
+export const withHour = (day: Date, minutes: number) =>
+  new Date(day.getFullYear(), day.getMonth(), day.getDate(), Math.floor(minutes / 60), minutes % 60);
+export const WEEKDAYS = ["dom", "seg", "ter", "qua", "qui", "sex", "sáb"];
+
+export function titleFor(view: CalendarView, cursor: Date) {
+  if (view === "month") return cursor.toLocaleDateString("pt-BR", { month: "long", year: "numeric" });
+  if (view === "day")
+    return cursor.toLocaleDateString("pt-BR", { weekday: "long", day: "numeric", month: "long", year: "numeric" });
+  const start = startOfWeek(cursor),
+    end = addDays(start, 6);
+  const short = (d: Date) => d.toLocaleDateString("pt-BR", { day: "numeric", month: "short" });
+  return `${short(start)} – ${short(end)} de ${end.getFullYear()}`;
+}
+
+export function stepCursor(view: CalendarView, cursor: Date, step: number) {
+  if (view === "month") return new Date(cursor.getFullYear(), cursor.getMonth() + step, 1);
+  return addDays(cursor, step * (view === "week" ? 7 : 1));
+}
+
+/* the day view grid */
+export const HOUR_HEIGHT = 64; /* px per hour */
+export const CARD_HEIGHT = 58; /* px: posts closer than this share the width */
+export const STEP_MIN = 5; /* dropping rounds to 5 min */
+
+/* --- drag ----------------------------------------------------------------------------------- */
+/* what is being dragged and where it was grabbed (px from the card top), for the day view */
+export type Drag = { post: Post; grabY: number } | null;
+export type DragController = {
+  /* for drawing (arrives one frame after dragstart) */
+  drag: Drag;
+  /* for deciding inside events: valid from dragstart on */
+  current: () => Drag;
+  start: (p: Post, e: DragEvent) => void;
+  end: () => void;
+};
+export const canDrag = (p: Post) => p.scheduled && p.state !== "publishing";
+
+export function draggable(p: Post, c: DragController) {
+  return {
+    draggable: canDrag(p),
+    onDragStart: (e: DragEvent) => c.start(p, e),
+    onDragEnd: c.end,
+  };
+}
+
+/* a day that takes the post: highlighted while the post is over it; a past day doesn't take it.
+   `className` is " target" while hovered */
+export function useDayDropTarget(d: Date, today: Date, c: DragController, drop: (p: Post, d: Date) => void) {
+  const [over, setOver] = useState(false);
+  const accepts = () => !!c.current() && d >= today;
+  return {
+    className: over && c.drag ? " target" : "",
+    props: {
+      onDragOver: (e: DragEvent) => {
+        if (!accepts()) return;
+        e.preventDefault();
+        e.dataTransfer.dropEffect = "move";
+        if (!over) setOver(true);
+      },
+      onDragLeave: (e: DragEvent) => {
+        if (!(e.currentTarget as Node).contains(e.relatedTarget as Node)) setOver(false);
+      },
+      onDrop: (e: DragEvent) => {
+        e.preventDefault();
+        setOver(false);
+        const cur = c.current();
+        if (accepts() && cur) drop(cur.post, d);
+      },
+    },
+  };
+}
+
+/* the link params that open a post's video on the Publish stage */
+export const postLink = (p: Post) => ({
+  to: "/videos/$slug/$stage" as const,
+  params: { slug: p.slug, stage: "publish" },
+});
+
+/* picking a video's day: clicking the calendar picks the day (and, in the day view, the time) instead of opening */
+export type PickHandler = ((day: Date, minutes?: number) => void) | null;
+export const PickContext = createContext<PickHandler>(null);
+
+/* the video that came from the Publish stage to pick a day, as a post (for the modal) */
+export function postFromDraft(r: PublishDraft, videos: VideoSummary[] | null): Post {
+  const v = videos?.find(x => x.slug === r.slug);
+  return {
+    key: `${r.slug}:draft`,
+    scheduled: true,
+    slug: r.slug,
+    title: r.title,
+    when: r.when ? new Date(r.when) : new Date(),
+    platforms: Object.entries(r.checked)
+      .filter(([, yes]) => yes)
+      .map(([id]) => id as PlatformId),
+    state: "scheduled",
+    error: null,
+    img: v ? mediaUrl(v, v.thumbnail ?? v.cover) : null,
+    portrait: !!v?.format && v.format.h > v.format.w,
+  };
+}
+
+/* the suggested time when picking a day: the draft's; today, the next full hour; else 9h */
+export function suggestedHour(day: Date, now: Date, r: PublishDraft) {
+  if (r.when) {
+    const q = new Date(r.when);
+    if (withHour(day, q.getHours() * 60 + q.getMinutes()).getTime() > now.getTime() + 60_000) return hourOf(q);
+  }
+  if (sameDay(day, now)) return `${String(Math.min(23, now.getHours() + 1)).padStart(2, "0")}:00`;
+  return "09:00";
+}

package/studio/web/lib/caption-position.ts

@@ -0,0 +1,249 @@
+/* The burned-in caption's position and style (CaptionPositionEditor): the draft's types, the
+   video → scene → caption resolution the template does, and the draft edits, as pure functions. */
+
+export type NumericStyleKey =
+  | "background_opacity"
+  | "outline"
+  | "shadow_opacity"
+  | "shadow_blur"
+  | "shadow_x"
+  | "shadow_y";
+export type ColorStyleKey = "color" | "background" | "outline_color" | "shadow_color";
+export type CaptionStyle = Partial<Record<NumericStyleKey, number> & Record<ColorStyleKey, string>>;
+/* `hidden`: only at the caption level; a caption turned off is not burned into the video */
+export type CaptionOverride = { anchor?: string; x?: number; y?: number; hidden?: boolean } & CaptionStyle;
+export type EffectiveOverride = CaptionOverride & { anchor: string; x: number; y: number };
+export type Side = "top" | "bottom" | "left" | "right";
+export type Margins = Record<Side, number>;
+export type CaptionPosition = CaptionOverride & {
+  platform: string;
+  style: string;
+  safe?: Partial<Margins>;
+  scenes?: Record<string, CaptionOverride>;
+  individual?: Record<string, CaptionOverride>;
+};
+/* `original`: the text the line generated, when the text was edited in the UI */
+export type CaptionItem = {
+  id: string;
+  scene: string | null;
+  line: string | null;
+  s: number;
+  e: number;
+  text: string;
+  hidden?: boolean;
+  original?: string;
+};
+export type CaptionsData = {
+  format: { w: number; h: number; fps: number; aspect?: string };
+  safes: Record<string, Margins>;
+  anchors: string[];
+  styles: string[];
+  defaults: Record<string, Required<CaptionStyle>>;
+  limits: Record<string, number[]> /* [min, max, step] per style key */;
+  max_chars: number | null;
+  position: CaptionPosition;
+  captions_in_motion: boolean;
+  scenes: { id: string; title: string | null; start: number; duration: number; mp4: boolean }[];
+  captions: CaptionItem[];
+  error?: string;
+};
+export type Scope = "video" | "scene" | "caption";
+export type CaptionBox = {
+  id: string;
+  outside: boolean;
+  sides?: { side: Side; px: number }[];
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+} | null;
+export type Message = { ok: boolean; text: string } | null;
+/* one save request: a level of the position that changed */
+export type PositionRequest = { scope: Scope; target?: string; value: unknown };
+
+export const SAFE_AREA_LABEL: Record<string, string> = {
+  all: "Todas",
+  shorts: "Shorts",
+  tiktok: "TikTok",
+  reels: "Reels",
+  youtube: "YouTube",
+};
+export const SIDES: Side[] = ["top", "bottom", "left", "right"];
+export const SIDE_LABEL: Record<Side, string> = { top: "Topo", bottom: "Base", left: "Esquerda", right: "Direita" };
+export const OPPOSITE_SIDE: Record<Side, Side> = { top: "bottom", bottom: "top", left: "right", right: "left" };
+export const clone = <T>(o: T): T => JSON.parse(JSON.stringify(o));
+const STYLE_KEYS = [
+  "anchor",
+  "x",
+  "y",
+  "hidden",
+  "color",
+  "background",
+  "background_opacity",
+  "outline",
+  "outline_color",
+  "shadow_color",
+  "shadow_opacity",
+  "shadow_blur",
+  "shadow_x",
+  "shadow_y",
+];
+export const pick = (o?: CaptionOverride) =>
+  Object.fromEntries(
+    Object.entries(o ?? {}).filter(([k, v]) => STYLE_KEYS.includes(k) && v != null),
+  ) as CaptionOverride;
+
+/* the same resolution as the template: video → scene → caption */
+export function effectiveStyle(
+  p: CaptionPosition,
+  c: CaptionItem | undefined,
+  upTo: Scope = "caption",
+): EffectiveOverride {
+  const base = { anchor: "bottom-center", x: 0, y: 0, ...pick(p) };
+  if (!c || upTo === "video") return base as EffectiveOverride;
+  const withScene = { ...base, ...pick(c.scene ? p.scenes?.[c.scene] : undefined) };
+  return (upTo === "scene" ? withScene : { ...withScene, ...pick(p.individual?.[c.id]) }) as EffectiveOverride;
+}
+
+/* the captions an edit in the "caption" scope applies to: all the checked ones when sel is among them */
+export const targetCaptionsOf = (sel: string | null, checked: string[]) =>
+  sel ? (checked.length > 1 && checked.includes(sel) ? checked : [sel]) : [];
+
+/* sets a key on the scope's level (for every target in scene and caption) */
+export function withChange(
+  r: CaptionPosition,
+  scope: Scope,
+  targets: string[],
+  field: keyof CaptionOverride,
+  value: string | number,
+): CaptionPosition {
+  const n = clone(r);
+  if (scope === "video") (n as any)[field] = value;
+  else {
+    const group = scope === "scene" ? "scenes" : "individual";
+    for (const target of targets)
+      n[group] = { ...(n[group] ?? {}), [target]: { ...(n[group]?.[target] ?? {}), [field]: value } };
+  }
+  return n;
+}
+
+/* removes the key from this level only: back to the level above or to the style default */
+export function withoutField(
+  r: CaptionPosition,
+  scope: Scope,
+  targets: string[],
+  field: keyof CaptionOverride,
+): CaptionPosition {
+  const n = clone(r);
+  if (scope === "video") delete (n as any)[field];
+  else {
+    const group = scope === "scene" ? "scenes" : "individual";
+    for (const target of targets) {
+      const o = n[group]?.[target];
+      if (!o) continue;
+      delete o[field];
+      if (!Object.keys(pick(o)).length) delete n[group]![target];
+    }
+  }
+  return n;
+}
+
+/* drops the whole override of the targets (scene or caption level) */
+export function withoutOverride(r: CaptionPosition, scope: Scope, targets: string[]): CaptionPosition {
+  const n = clone(r);
+  const group = scope === "scene" ? "scenes" : "individual";
+  for (const target of targets) if (n[group]) delete n[group]![target];
+  return n;
+}
+
+/* turns the captions on or off in the video; on is the default, so only off is saved */
+export function withCaptionsShown(r: CaptionPosition, ids: string[], on: boolean): CaptionPosition {
+  const n = clone(r);
+  const map: Record<string, CaptionOverride> = { ...(n.individual ?? {}) };
+  for (const id of ids) {
+    const o: CaptionOverride = { ...(map[id] ?? {}) };
+    if (on) delete o.hidden;
+    else o.hidden = true;
+    if (Object.keys(pick(o)).length) map[id] = o;
+    else delete map[id];
+  }
+  if (Object.keys(map).length) n.individual = map;
+  else delete n.individual;
+  return n;
+}
+
+/* switching the platform restarts from it: the margin overrides were about the previous one */
+export function withGeneral(r: CaptionPosition, field: "platform" | "style", value: string): CaptionPosition {
+  const n = { ...r, [field]: value };
+  if (field === "platform") delete n.safe;
+  return n;
+}
+
+/* one safe-area margin: equal to the platform's, it stops being an override */
+export function withMargin(
+  r: CaptionPosition,
+  safes: Record<string, Margins>,
+  side: Side,
+  value: number,
+): CaptionPosition {
+  const n = clone(r);
+  const platformValue = safes[n.platform]?.[side] ?? 0;
+  const v = Math.round(value * 1000) / 1000;
+  const safe = { ...(n.safe ?? {}) };
+  if (v === platformValue) delete safe[side];
+  else safe[side] = v;
+  if (Object.keys(safe).length) n.safe = safe;
+  else delete n.safe;
+  return n;
+}
+
+/* the largest a margin may get: 80 %, and at least 10 % of the frame left between it and the opposite one */
+export const marginMax = (oppositeValue: number) => Math.min(0.8, Math.round((0.9 - oppositeValue) * 1000) / 1000);
+
+/* the save requests: one per level that changed between the saved position and the draft */
+export function saveRequests(saved: CaptionPosition, draft: CaptionPosition): PositionRequest[] {
+  const requests: PositionRequest[] = [];
+  const general = (p: CaptionPosition) => JSON.stringify([p.platform, p.style, pick(p), p.safe ?? null]);
+  if (general(saved) !== general(draft))
+    requests.push({
+      scope: "video",
+      value: { platform: draft.platform, style: draft.style, ...pick(draft), safe: draft.safe ?? null },
+    });
+  for (const [group, s] of [
+    ["scenes", "scene"],
+    ["individual", "caption"],
+  ] as const) {
+    const a = saved[group] ?? {},
+      b = draft[group] ?? {};
+    for (const id of new Set([...Object.keys(a), ...Object.keys(b)])) {
+      if (JSON.stringify(pick(a[id])) !== JSON.stringify(pick(b[id])))
+        requests.push({ scope: s, target: id, value: Object.keys(pick(b[id])).length ? pick(b[id]) : null });
+    }
+  }
+  return requests;
+}
+
+/* a click in the list: alone picks one; shift checks the range; ⌘/ctrl checks or unchecks one.
+   Returns only what changes (null: nothing does) */
+export function chooseCaption(
+  ids: string[],
+  state: { sel: string | null; checked: string[]; rangeStart: string | null },
+  id: string,
+  keys: { shift: boolean; toggle: boolean },
+): { sel?: string; checked?: string[]; scope?: Scope; rangeStart?: string } | null {
+  const { sel, checked, rangeStart } = state;
+  const currentIds = sel ? (checked.includes(sel) ? checked : [sel]) : [];
+  if (keys.shift && (rangeStart ?? sel)) {
+    const [a, b] = [ids.indexOf((rangeStart ?? sel)!), ids.indexOf(id)].sort((x, y) => x - y);
+    return { checked: ids.slice(Math.max(a, 0), b + 1), sel: id, scope: "caption" };
+  }
+  if (keys.toggle) {
+    if (currentIds.includes(id)) {
+      const rest = currentIds.filter(x => x !== id);
+      if (!rest.length) return null;
+      return { checked: rest, ...(id === sel ? { sel: rest.at(-1)! } : {}), rangeStart: id, scope: "caption" };
+    }
+    return { checked: ids.filter(x => x === id || currentIds.includes(x)), sel: id, rangeStart: id, scope: "caption" };
+  }
+  return { sel: id, checked: [id], rangeStart: id };
+}

package/studio/web/lib/carousel.ts

@@ -0,0 +1,24 @@
+/* Shared bits of the carousel stages (pages/VideoPage/components/Carousel*.tsx). */
+
+import type { CarouselSlide } from "../types/api";
+
+export const ROLE_LABEL: Record<NonNullable<CarouselSlide["role"]>, string> = {
+  cover: "Capa",
+  content: "Conteúdo",
+  payoff: "Payoff",
+  cta: "CTA",
+};
+export const roleLabel = (role: string) => ROLE_LABEL[role as keyof typeof ROLE_LABEL] ?? role;
+
+/* carousel.json `goal` (EN enum on disk), shown as the PT word the file used to hold */
+const GOAL_LABEL: Record<string, string> = {
+  saves: "salvamento",
+  shares: "compartilhamento",
+  followers: "seguidor",
+  lead: "lead",
+};
+export const goalLabel = (goal: string) => GOAL_LABEL[goal] ?? goal;
+
+/* the slide's aspect ratio, 4:5 when the format is unknown */
+export const slideAspect = (format: { w: number; h: number } | null) =>
+  format ? `${format.w} / ${format.h}` : "4 / 5";

package/studio/web/lib/chime.ts

@@ -0,0 +1,42 @@
+/* A synthesized chime (Web Audio) for approval rounds. The browser only plays after some click
+   on the page, so the tab title is the notice that always arrives. */
+
+let ctx: AudioContext | null = null;
+const audioContext = () => (ctx ??= new AudioContext());
+
+/* without a gesture on the page, Chrome keeps the context suspended */
+const unlockAudio = () => {
+  try {
+    void audioContext().resume();
+  } catch {
+    /* no audio */
+  }
+};
+window.addEventListener("pointerdown", unlockAudio, { once: true });
+window.addEventListener("keydown", unlockAudio, { once: true });
+
+/* two short rising notes: get attention without startling */
+export function playChime() {
+  try {
+    const c = audioContext();
+    void c.resume();
+    const t0 = c.currentTime + 0.02;
+    for (const [freq, delay] of [
+      [880, 0],
+      [1318.5, 0.16],
+    ]) {
+      const osc = c.createOscillator();
+      const gain = c.createGain();
+      osc.type = "sine";
+      osc.frequency.value = freq;
+      gain.gain.setValueAtTime(0, t0 + delay);
+      gain.gain.linearRampToValueAtTime(0.22, t0 + delay + 0.012);
+      gain.gain.exponentialRampToValueAtTime(0.0001, t0 + delay + 0.6);
+      osc.connect(gain).connect(c.destination);
+      osc.start(t0 + delay);
+      osc.stop(t0 + delay + 0.65);
+    }
+  } catch {
+    /* browser without Web Audio: the title remains */
+  }
+}

package/studio/web/lib/clone-voice.ts

@@ -0,0 +1,55 @@
+/* The voice clone's pure rules (CloneVoiceDialog): the speech limits, the providers that clone
+   through the API, the pace of the guided reading, the file checks and the provider priority. */
+
+/* 30 s to 3 min of speech; the server checks the same limits (api/services/clone.ts) */
+export const MIN_S = 30;
+export const MAX_S = 180;
+export const MAX_FILE = 10 * 1024 ** 2;
+/* the providers that clone through the API; each one's account is in lib/providers (PROVIDER_ACCOUNT_URL) */
+export const PROVIDERS = [
+  { id: "fish", name: "Fish Audio" },
+  { id: "cartesia", name: "Cartesia" },
+] as const;
+export type CloneProviderId = (typeof PROVIDERS)[number]["id"];
+
+export const clock = (s: number) => `${Math.floor(s / 60)}:${String(Math.floor(s % 60)).padStart(2, "0")}`;
+
+/* Pace of the guided reading: each word lasts a bit longer the longer it is, and punctuation holds
+   the breath. ~2.7 words/s, the pace of natural, fluid speech for the clone to learn. Tune here to
+   speed up or slow down. */
+export const PACE = { base: 0.14, perLetter: 0.045, comma: 0.2, period: 0.35 };
+
+export function wordStarts(words: string[]): number[] {
+  let t = 0;
+  return words.map(w => {
+    const start = t;
+    t += PACE.base + PACE.perLetter * w.replace(/[^\p{L}\p{N}]/gu, "").length;
+    if (/[.!?…]["')»]*$/.test(w)) t += PACE.period;
+    else if (/[,;:—–]["')»]*$/.test(w)) t += PACE.comma;
+    return start;
+  });
+}
+
+/* the context's phrases as one continuous script, word by word */
+export const scriptWords = (phrases: { text: string }[]) =>
+  phrases
+    .map(f => f.text)
+    .join(" ")
+    .split(/\s+/)
+    .filter(Boolean);
+
+/* why a picked file can't be attached (too big, or not audio); null when it can */
+export function fileRefusal(f: { name: string; size: number; type: string }): string | null {
+  if (f.size > MAX_FILE) return `${f.name} passa de 10 MB`;
+  if (!/^(audio|video)\//.test(f.type) && !/\.(wav|mp3|m4a|webm|ogg|flac)$/i.test(f.name))
+    return `${f.name} não parece áudio`;
+  return null;
+}
+
+/* swaps the checked provider at `i` with its neighbour (`d`): the new priority keeps the unchecked
+   ones after the checked */
+export function reorderPriority(order: string[], priority: string[], i: number, d: -1 | 1): string[] {
+  const o = [...order];
+  [o[i], o[i + d]] = [o[i + d], o[i]];
+  return [...o, ...priority.filter(x => !o.includes(x))];
+}

package/studio/web/lib/export.ts

@@ -0,0 +1,11 @@
+import type { FileEntry, VideoDetail } from "../types/api";
+
+/* the current export: the one assembly.json names, else Premiere's, else the newest mp4 in export/ */
+export function currentExport(video: VideoDetail): FileEntry | null {
+  const mp4s = video.files.filter(f => f.path.startsWith("export/") && /\.(mp4|mov)$/i.test(f.path));
+  const fromAssembly = video.assembly?.mp4 ? mp4s.find(f => f.path === video.assembly!.mp4) : undefined;
+  const fromPremiere = video.premiere?.export
+    ? mp4s.find(f => String(video.premiere!.export).endsWith(`/${f.path}`))
+    : undefined;
+  return fromAssembly ?? fromPremiere ?? [...mp4s].sort((a, b) => b.mtime - a.mtime)[0] ?? null;
+}

package/studio/web/lib/files.ts

@@ -0,0 +1,8 @@
+/* a Blob as base64 (without the data: prefix), for JSON uploads */
+export const blobToBase64 = (b: Blob) =>
+  new Promise<string>((resolve, reject) => {
+    const r = new FileReader();
+    r.onload = () => resolve(String(r.result).split(",")[1] ?? "");
+    r.onerror = () => reject(r.error);
+    r.readAsDataURL(b);
+  });