@omelhorsite/video-sdk 0.2.0

package/dist/index.js

@@ -0,0 +1,1197 @@
+// src/types.ts
+var RESOLUTION_PRESETS = [
+  { id: "1080x1920", label: "9:16 (1080x1920)", width: 1080, height: 1920 },
+  { id: "1920x1080", label: "16:9 (1920x1080)", width: 1920, height: 1080 },
+  { id: "1080x1080", label: "1:1 (1080x1080)", width: 1080, height: 1080 },
+  { id: "720x1280", label: "9:16 (720x1280)", width: 720, height: 1280 },
+  { id: "1280x720", label: "16:9 (1280x720)", width: 1280, height: 720 }
+];
+var projectDuration = (project) => {
+  let end = 0;
+  for (const track of project.tracks)
+    for (const clip of track.clips)
+      end = Math.max(end, clip.start + clip.duration);
+  return end;
+};
+var findAsset = (project, id) => project.assets.find((a) => a.id === id);
+var emptyProject = (width = 1080, height = 1920, fps = 30) => ({
+  id: crypto.randomUUID().slice(0, 8),
+  name: "Sem titulo",
+  width,
+  height,
+  fps,
+  background: "#000000",
+  tracks: [
+    { id: "t-video", kind: "video", name: "Video 1", clips: [] },
+    { id: "t-music", kind: "audio", name: "Musica", clips: [] },
+    { id: "t-text", kind: "text", name: "Texto", clips: [] }
+  ],
+  assets: []
+});
+// src/placement.ts
+var computePlacement = (assetWidth, assetHeight, project, transform) => {
+  const fit = Math.min(project.width / assetWidth, project.height / assetHeight);
+  const width = Math.max(2, Math.round(assetWidth * fit * transform.scale));
+  const height = Math.max(2, Math.round(assetHeight * fit * transform.scale));
+  return {
+    x: Math.round(transform.x * project.width - width / 2),
+    y: Math.round(transform.y * project.height - height / 2),
+    width,
+    height
+  };
+};
+var fadeFactor = (t, clip) => {
+  const rel = t - clip.start;
+  if (rel < 0 || rel > clip.duration)
+    return 0;
+  const fin = clip.fadeIn > 0 ? Math.min(1, Math.max(0, rel / clip.fadeIn)) : 1;
+  const fout = clip.fadeOut > 0 ? Math.min(1, Math.max(0, (clip.duration - rel) / clip.fadeOut)) : 1;
+  return fin * fout;
+};
+// src/fx.ts
+var FLASH_STRIPS = 96;
+var FLASH_WAVE_SPEED = 1.5;
+var PEAK_AT = 0.66;
+var RISE_SHAPE = 0.7;
+var FALL_SHAPE = 0.99;
+var HOLD_GAIN = 1.014;
+var SPREAD = 0.24;
+var REACH = 0.71;
+var WARM_AT = 0.91;
+var HOT_AT = 0.63;
+var FLASH_CUT_AT = 0.476;
+var DEFAULT_FLASH = {
+  intensity: 0.85,
+  punch: 0.06,
+  wave: 0.02,
+  freq: 3.2,
+  color: "#ffffff",
+  warm: "#f8f399",
+  focusX: 0.34,
+  focusY: 0.72
+};
+var DEFAULT_FLASH_DURATION = 0.25;
+var smoothstep = (x) => {
+  const c = x < 0 ? 0 : x > 1 ? 1 : x;
+  return c * c * (3 - 2 * c);
+};
+var flashEnvelope = (p) => {
+  if (p <= 0 || p >= 1)
+    return 0;
+  const ramp = p < PEAK_AT ? Math.pow(p / PEAK_AT, RISE_SHAPE) : Math.pow((1 - p) / (1 - PEAK_AT), FALL_SHAPE);
+  return Math.min(1, smoothstep(ramp) * HOLD_GAIN);
+};
+var flashStateAt = (t, clip) => {
+  if (clip.duration <= 0)
+    return null;
+  const progress = (t - clip.start) / clip.duration;
+  if (progress < 0 || progress > 1)
+    return null;
+  const envelope = flashEnvelope(progress);
+  return {
+    progress,
+    envelope,
+    zoom: 1 + clip.punch * envelope,
+    amp: clip.wave * envelope,
+    phase: progress * 2 * Math.PI * FLASH_WAVE_SPEED
+  };
+};
+var flashGlowAtRadius = (state, clip, r) => {
+  const g = Math.min(1, Math.max(0, state.envelope * (1 + SPREAD) - SPREAD * r / REACH));
+  return {
+    alpha: clip.intensity * smoothstep(g),
+    hot: smoothstep((g - WARM_AT) / (1 - WARM_AT)) * smoothstep((state.envelope - HOT_AT) / (1 - HOT_AT))
+  };
+};
+var flashGlowAt = (state, clip, xNormalized, yNormalized, aspect) => flashGlowAtRadius(state, clip, Math.hypot((xNormalized - clip.focusX) * aspect, yNormalized - clip.focusY));
+var flashGlowReach = (state) => state.envelope <= 0 ? 0 : state.envelope * (1 + SPREAD) * REACH / SPREAD;
+var SHADOW_OPACITY = 0.5;
+var SHADOW_DROP = 0.45;
+var shadowMargin = (sigmaPixels) => Math.ceil(sigmaPixels * 3 + sigmaPixels * SHADOW_DROP);
+var flashBandOffset = (state, freq, band) => state.amp * Math.sin(band * 2 * Math.PI * freq + state.phase);
+var flashBandOf = (yNormalized) => Math.floor(yNormalized * FLASH_STRIPS) / FLASH_STRIPS;
+var makeFlashClip = (id, cutAt, overrides = {}) => {
+  const duration = overrides.duration ?? DEFAULT_FLASH_DURATION;
+  return {
+    id,
+    kind: "fx",
+    fx: "flash",
+    start: Math.max(0, cutAt - FLASH_CUT_AT * duration),
+    duration,
+    fadeIn: 0,
+    fadeOut: 0,
+    ...DEFAULT_FLASH,
+    ...overrides
+  };
+};
+var flashCutTime = (clip) => clip.start + FLASH_CUT_AT * clip.duration;
+var hexToYuv = (hex) => {
+  const h = hex.replace(/^#/, "");
+  const r = parseInt(h.slice(0, 2), 16) || 0;
+  const g = parseInt(h.slice(2, 4), 16) || 0;
+  const b = parseInt(h.slice(4, 6), 16) || 0;
+  return [
+    0.299 * r + 0.587 * g + 0.114 * b,
+    128 - 0.168736 * r - 0.331264 * g + 0.5 * b,
+    128 + 0.5 * r - 0.418688 * g - 0.081312 * b
+  ];
+};
+var n = (x) => {
+  const s = x.toFixed(6);
+  return s.replace(/\.?0+$/, "") || "0";
+};
+var flashGeqExpr = (clip, warmValue, coldValue) => {
+  const sm = (reg) => `ld(${reg})*ld(${reg})*(3-2*ld(${reg}))`;
+  return [
+    `st(1, clip((T-${n(clip.start)})/${n(clip.duration)}, 0, 1))`,
+    `st(2, clip(if(lt(ld(1),${n(PEAK_AT)}), pow(ld(1)/${n(PEAK_AT)},${n(RISE_SHAPE)}), pow((1-ld(1))/${n(1 - PEAK_AT)},${n(FALL_SHAPE)})), 0, 1))`,
+    `st(2, clip(${sm(2)}*${n(HOLD_GAIN)}, 0, 1))`,
+    `st(3, 1+${n(clip.punch)}*ld(2))`,
+    `st(6, ${n(clip.wave)}*W*ld(2)*sin(floor(Y/H*${FLASH_STRIPS})/${FLASH_STRIPS}` + `*2*PI*${n(clip.freq)} + ld(1)*2*PI*${n(FLASH_WAVE_SPEED)}))`,
+    `st(7, hypot((X/W-${n(clip.focusX)})*(W/H), Y/H-${n(clip.focusY)}))`,
+    `st(8, clip(ld(2)*${n(1 + SPREAD)} - ${n(SPREAD / REACH)}*ld(7), 0, 1))`,
+    `st(5, ${n(clip.intensity)}*(${sm(8)}))`,
+    `st(4, clip((ld(2)-${n(HOT_AT)})/${n(1 - HOT_AT)}, 0, 1))`,
+    `st(9, clip((ld(8)-${n(WARM_AT)})/${n(1 - WARM_AT)}, 0, 1))`,
+    `st(9, (${sm(9)})*(${sm(4)}))`,
+    `p((X-W/2)/ld(3)+W/2+ld(6), (Y-H/2)/ld(3)+H/2)*(1-ld(5))` + ` + (${n(warmValue)} + ${n(coldValue - warmValue)}*ld(9))*ld(5)`
+  ].join("; ");
+};
+
+// src/compile.ts
+var fmt = (n2) => {
+  const s = n2.toFixed(4);
+  return s.replace(/\.?0+$/, "") || "0";
+};
+var BLUR_PASSES = 2;
+var blurSteps = (sigma, enable) => {
+  const r = Math.max(1, Math.round((-1 + Math.sqrt(1 + 12 * sigma * sigma / BLUR_PASSES)) / 2));
+  return Array.from({ length: BLUR_PASSES }, () => `avgblur=sizeX=${r}:sizeY=${r}:${enable}`).join(",");
+};
+var hexColor = (color) => `0x${color.replace(/[^0-9a-fA-F]/g, "").padStart(6, "0")}`;
+var compile = (project, options) => {
+  const duration = projectDuration(project);
+  if (duration <= 0)
+    throw new Error("timeline vazia: nada para exportar");
+  const inputs = [];
+  let inputCount = 0;
+  const visuals = [];
+  const audios = [];
+  const texts = [];
+  const effects = [];
+  const videoTracks = project.tracks.filter((t) => t.kind === "video" && !t.muted);
+  const audioTracks = project.tracks.filter((t) => t.kind === "audio" && !t.muted);
+  const textTracks = project.tracks.filter((t) => t.kind === "text" && !t.muted);
+  for (const track of videoTracks) {
+    for (const clip of [...track.clips].sort((a, b) => a.start - b.start)) {
+      if (clip.kind === "fx") {
+        effects.push(clip);
+        continue;
+      }
+      if (clip.kind !== "video" && clip.kind !== "image")
+        continue;
+      const asset = findAsset(project, clip.assetId);
+      if (!asset)
+        throw new Error(`asset em falta: ${clip.assetId}`);
+      if (!asset.width || !asset.height)
+        throw new Error(`asset visual sem dimensoes: ${asset.name}`);
+      if (clip.kind === "image") {
+        inputs.push("-loop", "1", "-t", fmt(clip.duration), "-i", asset.path);
+      } else {
+        inputs.push("-ss", fmt(clip.in), "-t", fmt(clip.duration), "-i", asset.path);
+      }
+      const inputIndex = inputCount++;
+      visuals.push({ clip, inputIndex, assetWidth: asset.width, assetHeight: asset.height });
+      if (clip.kind === "video" && !clip.muted && clip.volume > 0) {
+        audios.push({
+          start: clip.start,
+          duration: clip.duration,
+          fadeIn: clip.fadeIn,
+          fadeOut: clip.fadeOut,
+          volume: clip.volume,
+          inputIndex
+        });
+      }
+    }
+  }
+  for (const track of audioTracks) {
+    for (const clip of [...track.clips].sort((a, b) => a.start - b.start)) {
+      if (clip.kind !== "audio")
+        continue;
+      const asset = findAsset(project, clip.assetId);
+      if (!asset)
+        throw new Error(`asset em falta: ${clip.assetId}`);
+      inputs.push("-ss", fmt(clip.in), "-t", fmt(clip.duration), "-i", asset.path);
+      audios.push({
+        start: clip.start,
+        duration: clip.duration,
+        fadeIn: clip.fadeIn,
+        fadeOut: clip.fadeOut,
+        volume: clip.volume,
+        inputIndex: inputCount++
+      });
+    }
+  }
+  for (const fx of effects) {
+    if (!fx.soundAssetId)
+      continue;
+    const asset = findAsset(project, fx.soundAssetId);
+    if (!asset)
+      throw new Error(`asset em falta no flash ${fx.id}: ${fx.soundAssetId}`);
+    const cut = flashCutTime(fx);
+    const soundDuration = Math.min(asset.duration ?? fx.duration, duration - cut);
+    if (soundDuration <= 0)
+      continue;
+    inputs.push("-t", fmt(soundDuration), "-i", asset.path);
+    audios.push({
+      start: cut,
+      duration: soundDuration,
+      fadeIn: 0,
+      fadeOut: 0,
+      volume: fx.soundVolume ?? 1,
+      inputIndex: inputCount++
+    });
+  }
+  for (const track of textTracks) {
+    for (const clip of [...track.clips].sort((a, b) => a.start - b.start)) {
+      if (clip.kind === "text" && clip.text.trim())
+        texts.push(clip);
+    }
+  }
+  const graph = [];
+  graph.push(`color=c=${hexColor(project.background)}:s=${project.width}x${project.height}` + `:r=${fmt(project.fps)}:d=${fmt(duration)}[bg]`);
+  let current = "bg";
+  let chainId = 0;
+  for (const { clip, inputIndex, assetWidth, assetHeight } of visuals) {
+    const place = computePlacement(assetWidth, assetHeight, project, clip.transform);
+    const steps = [
+      `fps=${fmt(project.fps)}`,
+      `scale=${place.width}:${place.height}:flags=${options.scaleFlags ?? "lanczos"}`,
+      "setsar=1",
+      "format=rgba"
+    ];
+    if (clip.transform.opacity < 1)
+      steps.push(`colorchannelmixer=aa=${fmt(clip.transform.opacity)}`);
+    if (clip.fadeIn > 0)
+      steps.push(`fade=t=in:st=0:d=${fmt(clip.fadeIn)}:alpha=1`);
+    if (clip.fadeOut > 0)
+      steps.push(`fade=t=out:st=${fmt(Math.max(0, clip.duration - clip.fadeOut))}:d=${fmt(clip.fadeOut)}:alpha=1`);
+    steps.push(`setpts=PTS-STARTPTS+${fmt(clip.start)}/TB`);
+    if (clip.blurBehind && clip.blurBehind > 0) {
+      const sigma = clip.blurBehind * project.width;
+      const blurred = `b${chainId}`;
+      const gate = `enable='between(t,${fmt(clip.start)},${fmt(clip.start + clip.duration)})'`;
+      graph.push(`[${current}]${blurSteps(sigma, gate)}[${blurred}]`);
+      current = blurred;
+    }
+    const label = `v${chainId}`;
+    const out = `c${chainId}`;
+    const window = `enable='between(t,${fmt(clip.start)},${fmt(clip.start + clip.duration)})'`;
+    graph.push(`[${inputIndex}:v]${steps.join(",")}[${label}]`);
+    let over = label;
+    if (clip.shadow && clip.shadow > 0) {
+      const sigma = clip.shadow * project.width;
+      const margin = shadowMargin(sigma);
+      const shape = `s${chainId}`;
+      const shadow = `sh${chainId}`;
+      const lifted = `l${chainId}`;
+      graph.push(`[${label}]split[${over = `k${chainId}`}][${shape}]`);
+      graph.push(`[${shape}]pad=iw+${margin * 2}:ih+${margin * 2}:${margin}:${margin}:color=#00000000,` + `colorchannelmixer=rr=0:rg=0:rb=0:ra=0:gr=0:gg=0:gb=0:ga=0:` + `br=0:bg=0:bb=0:ba=0:ar=0:ag=0:ab=0:aa=${fmt(SHADOW_OPACITY)},` + `${blurSteps(sigma, "enable=1")}[${shadow}]`);
+      graph.push(`[${current}][${shadow}]overlay=x=${place.x - margin}` + `:y=${place.y - margin + Math.round(sigma * SHADOW_DROP)}:${window}[${lifted}]`);
+      current = lifted;
+    }
+    graph.push(`[${current}][${over}]overlay=x=${place.x}:y=${place.y}:${window}[${out}]`);
+    current = out;
+    chainId++;
+  }
+  for (const clip of texts) {
+    const raster = options.textImages?.[clip.id];
+    if (!raster)
+      throw new Error(`clip de texto sem raster (textImages['${clip.id}']): "${clip.text}"`);
+    inputs.push("-loop", "1", "-t", fmt(clip.duration), "-i", raster.path);
+    const inputIndex = inputCount++;
+    const x = Math.round(clip.x * project.width - raster.width / 2);
+    const y = Math.round(clip.y * project.height - raster.height / 2);
+    const steps = [`fps=${fmt(project.fps)}`, "setsar=1", "format=rgba"];
+    if (clip.fadeIn > 0)
+      steps.push(`fade=t=in:st=0:d=${fmt(clip.fadeIn)}:alpha=1`);
+    if (clip.fadeOut > 0)
+      steps.push(`fade=t=out:st=${fmt(Math.max(0, clip.duration - clip.fadeOut))}:d=${fmt(clip.fadeOut)}:alpha=1`);
+    steps.push(`setpts=PTS-STARTPTS+${fmt(clip.start)}/TB`);
+    const label = `v${chainId}`;
+    const out = `c${chainId}`;
+    graph.push(`[${inputIndex}:v]${steps.join(",")}[${label}]`);
+    graph.push(`[${current}][${label}]overlay=x=${x}:y=${y}` + `:enable='between(t,${fmt(clip.start)},${fmt(clip.start + clip.duration)})'[${out}]`);
+    current = out;
+    chainId++;
+  }
+  if (options.captionOverlay) {
+    const cap = options.captionOverlay;
+    inputs.push("-i", cap.path);
+    const inputIndex = inputCount++;
+    const label = `v${chainId}`;
+    const out = `c${chainId}`;
+    graph.push(`[${inputIndex}:v]fps=${fmt(project.fps)},setsar=1,format=rgba[${label}]`);
+    graph.push(`[${current}][${label}]overlay=x=${cap.x}:y=${cap.y}:eof_action=pass[${out}]`);
+    current = out;
+    chainId++;
+  }
+  if (effects.length) {
+    graph.push(`[${current}]format=yuv420p[fxin]`);
+    current = "fxin";
+    for (const fx of effects.sort((a, b) => a.start - b.start)) {
+      const cold = hexToYuv(fx.color);
+      const warm = hexToYuv(fx.warm);
+      const out = `fx${chainId}`;
+      graph.push(`[${current}]geq=lum='${flashGeqExpr(fx, warm[0], cold[0])}'` + `:cb='${flashGeqExpr(fx, warm[1], cold[1])}'` + `:cr='${flashGeqExpr(fx, warm[2], cold[2])}'` + `:enable='between(t,${fmt(fx.start)},${fmt(fx.start + fx.duration)})'[${out}]`);
+      current = out;
+      chainId++;
+    }
+  }
+  graph.push(`[${current}]format=yuv420p,setparams=color_primaries=bt709:color_trc=bt709:colorspace=bt709[vout]`);
+  const audioLabels = [];
+  audios.forEach((entry, i) => {
+    const steps = ["asetpts=PTS-STARTPTS"];
+    if (entry.volume !== 1)
+      steps.push(`volume=${fmt(entry.volume)}`);
+    if (entry.fadeIn > 0)
+      steps.push(`afade=t=in:st=0:d=${fmt(entry.fadeIn)}`);
+    if (entry.fadeOut > 0)
+      steps.push(`afade=t=out:st=${fmt(Math.max(0, entry.duration - entry.fadeOut))}:d=${fmt(entry.fadeOut)}`);
+    const delayMs = Math.round(entry.start * 1000);
+    if (delayMs > 0)
+      steps.push(`adelay=${delayMs}:all=1`);
+    const label = `a${i}`;
+    graph.push(`[${entry.inputIndex}:a]${steps.join(",")}[${label}]`);
+    audioLabels.push(label);
+  });
+  let audioOut = null;
+  if (audioLabels.length === 1) {
+    audioOut = audioLabels[0];
+  } else if (audioLabels.length > 1) {
+    graph.push(`${audioLabels.map((l) => `[${l}]`).join("")}amix=inputs=${audioLabels.length}` + `:duration=longest:normalize=0[aout]`);
+    audioOut = "aout";
+  }
+  const args = [
+    "-y",
+    ...inputs,
+    "-filter_complex",
+    graph.join(";"),
+    "-map",
+    "[vout]"
+  ];
+  if (audioOut)
+    args.push("-map", `[${audioOut}]`);
+  args.push("-r", fmt(project.fps), "-t", fmt(duration));
+  if (options.videoCodec === "videotoolbox") {
+    args.push("-c:v", "h264_videotoolbox", "-b:v", options.bitrate ?? "14000k", "-tag:v", "avc1", "-pix_fmt", "yuv420p");
+  } else {
+    args.push("-c:v", "libx264", "-preset", options.preset ?? "slow", "-crf", String(options.crf ?? 18), "-pix_fmt", "yuv420p");
+  }
+  args.push("-color_primaries", "bt709", "-color_trc", "bt709", "-colorspace", "bt709");
+  if (audioOut)
+    args.push("-c:a", "aac", "-b:a", options.audioBitrate ?? "192k");
+  args.push("-movflags", "+faststart", options.output);
+  return { args, duration };
+};
+// src/packfile.ts
+import { strFromU8, strToU8, unzipSync, zipSync } from "fflate";
+var OMSV_SCHEMA = 1;
+var isZipData = (bytes) => bytes.length > 1 && bytes[0] === 80 && bytes[1] === 75;
+var sanitize = (name) => name.replace(/[^A-Za-z0-9._-]+/g, "_").slice(0, 80);
+var assetEntryName = (asset) => `assets/${asset.id}-${sanitize(asset.name || "media")}`;
+var packProject = ({ project, assetBytes, appVersion, nowIso }) => {
+  const entries = {};
+  const relProject = {
+    ...project,
+    assets: project.assets.map((a) => assetBytes.has(a.id) ? { ...a, path: assetEntryName(a) } : a)
+  };
+  const manifest = {
+    format: "omsv",
+    schema: OMSV_SCHEMA,
+    savedAt: nowIso,
+    appVersion
+  };
+  entries["manifest.json"] = [strToU8(JSON.stringify(manifest, null, 2)), { level: 6 }];
+  entries["timeline.json"] = [strToU8(JSON.stringify(relProject, null, 2)), { level: 6 }];
+  for (const asset of relProject.assets) {
+    const bytes = assetBytes.get(asset.id);
+    if (bytes)
+      entries[asset.path] = [bytes, { level: 0 }];
+  }
+  return zipSync(entries);
+};
+var unpackProject = (bytes) => {
+  const files = unzipSync(bytes);
+  const timelineRaw = files["timeline.json"];
+  if (!timelineRaw)
+    throw new Error("ficheiro .omsv sem timeline.json");
+  const manifest = files["manifest.json"] ? JSON.parse(strFromU8(files["manifest.json"])) : { format: "omsv", schema: 0 };
+  if (manifest.schema > OMSV_SCHEMA)
+    throw new Error(`este projecto e de um schema mais recente (${manifest.schema} > ${OMSV_SCHEMA}); actualiza o software`);
+  const project = JSON.parse(strFromU8(timelineRaw));
+  const assetBytes = new Map;
+  for (const [name, data] of Object.entries(files))
+    if (name.startsWith("assets/") && !name.endsWith("/"))
+      assetBytes.set(name, data);
+  return { manifest, project, assetBytes };
+};
+// src/captions.ts
+var DEFAULT_CAPTION_STYLE = {
+  fontScale: 0.05,
+  strokeScale: 0.13,
+  pos: 0.78,
+  maxWords: 3,
+  maxChars: 20,
+  gap: 0.4,
+  tail: 0.12,
+  color: "#ffffff",
+  highlight: "#ffd600",
+  stroke: "#000000",
+  maxWidth: 0.9,
+  fontFamily: "Montserrat, Helvetica, Arial, sans-serif"
+};
+var SENT_END = ".?!:;,";
+var groupWords = (words, style) => {
+  const chunks = [];
+  let cur = [];
+  let chars = 0;
+  for (const w of words) {
+    const prev = cur[cur.length - 1];
+    const g = prev ? w.t0 - prev.t1 : 0;
+    const would = chars + w.text.length + (cur.length ? 1 : 0);
+    const brk = cur.length > 0 && (cur.length >= style.maxWords || would > style.maxChars || g > style.gap || prev !== undefined && SENT_END.includes(prev.text.slice(-1)));
+    if (brk) {
+      chunks.push(cur);
+      cur = [];
+      chars = 0;
+    }
+    cur.push(w);
+    chars += w.text.length + (cur.length > 1 ? 1 : 0);
+  }
+  if (cur.length)
+    chunks.push(cur);
+  return chunks;
+};
+var captionStates = (chunks, tail) => {
+  const states = [];
+  chunks.forEach((words, ci) => {
+    const next = ci + 1 < chunks.length ? chunks[ci + 1][0].t0 : undefined;
+    words.forEach((w, j) => {
+      const t0 = w.t0;
+      let t1;
+      if (j + 1 < words.length)
+        t1 = words[j + 1].t0;
+      else {
+        t1 = words[words.length - 1].t1 + tail;
+        if (next !== undefined)
+          t1 = Math.min(t1, next);
+      }
+      states.push({ words, active: j, t0, t1: Math.max(t1, t0) });
+    });
+  });
+  return states;
+};
+var sourceSpans = (project, assetId) => {
+  const spans = [];
+  for (const track of project.tracks) {
+    if (track.kind !== "video" || track.muted)
+      continue;
+    for (const clip of track.clips) {
+      if (clip.kind !== "video")
+        continue;
+      const v = clip;
+      if (v.assetId !== assetId)
+        continue;
+      spans.push({ in: v.in, out: v.in + v.duration, start: v.start });
+    }
+  }
+  return spans.sort((a, b) => a.start - b.start);
+};
+var BORDA = 0.12;
+var remapWords = (words, spans, borda = BORDA) => {
+  const out = [];
+  for (const w of words) {
+    let best;
+    for (const span2 of spans) {
+      const overlap = Math.min(w.t1, span2.out + borda) - Math.max(w.t0, span2.in - borda);
+      if (overlap <= 0)
+        continue;
+      if (!best || overlap > best.overlap)
+        best = { span: span2, overlap };
+    }
+    if (!best)
+      continue;
+    const { span } = best;
+    const t0 = Math.min(Math.max(w.t0, span.in), span.out) - span.in + span.start;
+    const t1 = Math.min(Math.max(w.t1, span.in), span.out) - span.in + span.start;
+    if (t1 > t0)
+      out.push({ t0, t1, text: w.text });
+  }
+  return out.sort((a, b) => a.t0 - b.t0);
+};
+var timelineWords = (project) => {
+  const all = [];
+  for (const src of project.captions ?? [])
+    all.push(...remapWords(src.words, sourceSpans(project, src.assetId)));
+  return all.sort((a, b) => a.t0 - b.t0);
+};
+// src/slice.ts
+var temSource = (c) => c.kind === "video" || c.kind === "image" || c.kind === "audio";
+var sliceClip = (clip, from, to) => {
+  const end = clip.start + clip.duration;
+  if (end <= from || clip.start >= to)
+    return;
+  const cutFront = Math.max(0, from - clip.start);
+  const cutBack = Math.max(0, end - to);
+  const duration = clip.duration - cutFront - cutBack;
+  if (duration <= 0)
+    return;
+  const out = {
+    ...clip,
+    start: Math.max(0, clip.start - from),
+    duration,
+    fadeIn: cutFront > 0 ? Math.max(0, clip.fadeIn - cutFront) : clip.fadeIn,
+    fadeOut: cutBack > 0 ? Math.max(0, clip.fadeOut - cutBack) : clip.fadeOut
+  };
+  if (cutFront > 0 && temSource(out) && out.kind !== "image")
+    out.in = clip.in + cutFront;
+  return out;
+};
+var sliceProject = (project, from, to) => {
+  if (!(to > from))
+    throw new Error(`janela invalida: ${from}..${to}`);
+  return {
+    ...project,
+    tracks: project.tracks.map((track) => ({
+      ...track,
+      clips: track.clips.map((c) => sliceClip(c, from, to)).filter((c) => c !== undefined)
+    }))
+  };
+};
+// src/cloud/cloud.ts
+import {
+  CAPTION_CHUNKED_THRESHOLD,
+  OAuthTokenProvider,
+  Oms,
+  OmsApiError,
+  OmsAuthError,
+  OmsDeviceDeniedError,
+  OmsDeviceExpiredError,
+  OmsError,
+  OmsNetworkError,
+  OmsQuotaError,
+  OmsTimeoutError,
+  captionUploadSize,
+  collect,
+  decodeIdToken,
+  fetchToolArtifact,
+  file,
+  readInsufficientScope,
+  scopesOf
+} from "@omelhorsite/sdk";
+
+// src/cloud/srt.ts
+var TIME = /(\d+):(\d\d):(\d\d)[,.](\d{1,3})/;
+var parseTime = (raw) => {
+  const m = TIME.exec(raw);
+  if (!m)
+    return;
+  const ms = m[4].padEnd(3, "0");
+  return Number(m[1]) * 3600 + Number(m[2]) * 60 + Number(m[3]) + Number(ms) / 1000;
+};
+var parseSrt = (text) => {
+  const cues = [];
+  const blocks = text.replace(/\r/g, "").replace(/^WEBVTT[^\n]*\n/, "").split(/\n\s*\n/);
+  for (const block of blocks) {
+    const lines = block.split(`
+`).map((l) => l.trim()).filter((l) => l.length > 0);
+    const arrowAt = lines.findIndex((l) => l.includes("-->"));
+    if (arrowAt < 0)
+      continue;
+    const [a, b] = lines[arrowAt].split("-->");
+    const t0 = parseTime(a ?? "");
+    const t1 = parseTime(b ?? "");
+    if (t0 === undefined || t1 === undefined)
+      continue;
+    const body = lines.slice(arrowAt + 1).join(" ").replace(/<[^>]+>/g, "").replace(/\s+/g, " ").trim();
+    if (!body)
+      continue;
+    cues.push({ t0, t1: Math.max(t1, t0), text: body });
+  }
+  return cues;
+};
+var MIN_WORD = 0.06;
+var wordsFromCues = (cues) => {
+  const out = [];
+  const sorted = [...cues].sort((a, b) => a.t0 - b.t0);
+  sorted.forEach((cue, i) => {
+    const tokens = cue.text.split(/\s+/).filter((t) => t.length > 0);
+    if (!tokens.length)
+      return;
+    const next = sorted[i + 1]?.t0;
+    const end = next !== undefined ? Math.min(cue.t1, next) : cue.t1;
+    const span = Math.max(end - cue.t0, MIN_WORD * tokens.length);
+    const weights = tokens.map((t) => t.length + 1);
+    const total = weights.reduce((s, w) => s + w, 0);
+    let cursor = cue.t0;
+    tokens.forEach((text, j) => {
+      const dur = span * weights[j] / total;
+      const t0 = cursor;
+      const t1 = j === tokens.length - 1 ? cue.t0 + span : cursor + dur;
+      out.push({ t0, t1: Math.max(t1, t0 + MIN_WORD), text });
+      cursor = t1;
+    });
+  });
+  return out;
+};
+
+// src/cloud/cloud.ts
+var DEFAULT_CLIENT_ID = "oms-video";
+var OMS_VIDEO_SCOPES = [
+  "openid",
+  "storage:read",
+  "storage:write",
+  "tools:read",
+  "tools:write"
+];
+var PROJECTS_FOLDER = "oms-video";
+var PROJECT_EXTENSION = ".omsv";
+var withExtension = (name) => {
+  const clean = name.replace(/[\/\\]+/g, "_").trim() || "projecto";
+  return clean.toLowerCase().endsWith(PROJECT_EXTENSION) ? clean : `${clean}${PROJECT_EXTENSION}`;
+};
+var toFileInput = (input) => file(input.data, input.name, {
+  ...input.size === undefined ? {} : { size: input.size },
+  ...input.contentType === undefined ? {} : { contentType: input.contentType }
+});
+var sizeOf = (input) => input.size ?? (input.data instanceof Blob ? input.data.size : input.data.byteLength);
+var toProject = (node) => ({
+  id: node.id,
+  name: node.name,
+  size: node.size,
+  createdAt: node.created_at,
+  updatedAt: node.updated_at
+});
+
+class Cloud {
+  clientId;
+  baseUrl;
+  scopes;
+  anon;
+  tokens;
+  oms;
+  usesOAuth;
+  store;
+  folderId;
+  constructor(options) {
+    this.clientId = options.clientId ?? DEFAULT_CLIENT_ID;
+    this.scopes = options.scopes ?? OMS_VIDEO_SCOPES;
+    this.store = options.store;
+    const shared = {
+      ...options.baseUrl === undefined ? {} : { baseUrl: options.baseUrl },
+      ...options.fetch === undefined ? {} : { fetch: options.fetch },
+      ...options.clientName === undefined ? {} : { clientName: options.clientName }
+    };
+    this.anon = new Oms(shared);
+    this.baseUrl = this.anon.baseUrl;
+    if (options.sessionToken) {
+      this.tokens = null;
+      this.usesOAuth = false;
+      this.oms = new Oms({ ...shared, token: options.sessionToken });
+    } else {
+      this.tokens = new OAuthTokenProvider({
+        store: options.store,
+        refresh: (refreshToken) => this.anon.auth.refresh(refreshToken, { clientId: this.clientId })
+      });
+      this.usesOAuth = true;
+      this.oms = new Oms({ ...shared, tokens: this.tokens });
+    }
+  }
+  client() {
+    return this.oms;
+  }
+  async login(options) {
+    if (!this.tokens)
+      throw new OmsError("Esta instancia usa um token de sessao fixo; nao ha' login a fazer.", "invalid_request");
+    const grant = await this.anon.auth.device.start({
+      clientId: this.clientId,
+      scope: this.scopes.join(" ")
+    });
+    await options.onPrompt({ ...grant, url: grant.verificationUriComplete ?? grant.verificationUri });
+    const set = await this.anon.auth.device.wait({
+      clientId: this.clientId,
+      deviceCode: grant.deviceCode,
+      intervalMs: options.pollIntervalMs ?? grant.intervalMs,
+      expiresAt: grant.expiresAt,
+      ...options.onPoll === undefined ? {} : { onPoll: options.onPoll },
+      ...options.signal === undefined ? {} : { signal: options.signal }
+    });
+    await this.tokens.set(set);
+    return sessionFrom(set);
+  }
+  async logout() {
+    if (!this.tokens)
+      return;
+    const set = await this.store.load();
+    if (set?.refreshToken) {
+      try {
+        await this.anon.auth.revoke(set.refreshToken, { clientId: this.clientId });
+      } catch {}
+    }
+    await this.tokens.clear();
+  }
+  async session() {
+    if (!this.tokens)
+      return null;
+    const set = await this.store.load();
+    if (!set)
+      return null;
+    try {
+      return sessionFrom(set);
+    } catch {
+      return null;
+    }
+  }
+  async whoami() {
+    const stored = await this.session();
+    const claims = await this.oms.auth.userinfo();
+    const scopes = stored?.scopes ?? [];
+    let handle = typeof claims.preferred_username === "string" ? claims.preferred_username : undefined;
+    let email = typeof claims.email === "string" ? claims.email : undefined;
+    if (!this.usesOAuth || scopes.includes("profile")) {
+      try {
+        const me = await this.oms.auth.whoami();
+        handle = me.handle;
+        email = me.email ?? email;
+      } catch {}
+    }
+    return {
+      sub: claims.sub,
+      scopes,
+      ...stored?.expiresAt === undefined ? {} : { expiresAt: stored.expiresAt },
+      ...handle === undefined ? {} : { handle },
+      ...email === undefined ? {} : { email }
+    };
+  }
+  async projectsFolder() {
+    if (this.folderId) {
+      try {
+        return await this.oms.storage.get(this.folderId);
+      } catch {
+        this.folderId = undefined;
+      }
+    }
+    const roots = await this.oms.storage.roots();
+    if (!roots.home)
+      throw new OmsError("A conta nao tem pasta home no storage.", "not_found");
+    let node;
+    try {
+      node = await this.oms.storage.resolvePath(PROJECTS_FOLDER);
+      if (node.kind !== "directory")
+        throw new OmsError(`Existe um ficheiro chamado "${PROJECTS_FOLDER}" na home; a pasta dos projectos nao pode ser criada.`, "conflict");
+    } catch (e) {
+      if (!(e instanceof OmsError) || e.code !== "not_found")
+        throw e;
+      node = await this.oms.storage.createDirectory({ name: PROJECTS_FOLDER, parentId: roots.home });
+    }
+    this.folderId = node.id;
+    return node;
+  }
+  async listProjects() {
+    const folder = await this.projectsFolder();
+    const page = await this.oms.storage.list({ parentId: folder.id, order: "updated_at:desc" });
+    const nodes = await collect(page, 2000);
+    return nodes.filter((n2) => n2.kind === "file" && n2.name.toLowerCase().endsWith(PROJECT_EXTENSION)).map(toProject);
+  }
+  async findProject(idOrName) {
+    try {
+      const node = await this.oms.storage.get(idOrName);
+      if (node.kind === "file")
+        return toProject(node);
+    } catch (e) {
+      if (!(e instanceof OmsApiError) || e.status !== 404)
+        throw e;
+    }
+    const folder = await this.projectsFolder();
+    for (const name of [idOrName, withExtension(idOrName)]) {
+      const page = await this.oms.storage.list({ parentId: folder.id, exactSearch: { name }, pageSize: 2 });
+      const hit = page.items.find((n2) => n2.kind === "file");
+      if (hit)
+        return toProject(hit);
+    }
+    return null;
+  }
+  async uploadProject(input, options = {}) {
+    const name = withExtension(input.name);
+    const folder = await this.projectsFolder();
+    const existing = (await this.oms.storage.list({ parentId: folder.id, exactSearch: { name }, pageSize: 2 })).items.find((n2) => n2.kind === "file");
+    let backup;
+    if (existing)
+      backup = await this.oms.storage.rename(existing.id, `${name}.a-substituir-${Date.now()}`);
+    let node;
+    try {
+      const results = await this.oms.storage.uploads.upload({
+        parentId: folder.id,
+        files: [toFileInput({ ...input, name, size: sizeOf(input) })]
+      }, {
+        ...options.onProgress === undefined ? {} : { onProgress: options.onProgress },
+        ...options.signal === undefined ? {} : { signal: options.signal }
+      });
+      const result = results[0];
+      if (!result || result.error)
+        throw new OmsError(`O storage recusou "${name}"${result?.error ? ` (${result.error.code}): ${result.error.message}` : "."}`, result?.error?.code === "quota_exceeded" ? "quota_exceeded" : "invalid_request");
+      if (result.node)
+        node = result.node;
+      else if (result.fs_node_id)
+        node = await this.oms.storage.get(result.fs_node_id);
+      else
+        throw new OmsError(`O upload de "${name}" acabou sem no' de volta.`, "api_error");
+    } catch (e) {
+      if (backup) {
+        try {
+          await this.oms.storage.rename(backup.id, name);
+        } catch {}
+      }
+      throw e;
+    }
+    if (backup) {
+      try {
+        await this.oms.storage.trash([backup.id]);
+      } catch {}
+    }
+    return toProject(node);
+  }
+  async downloadProject(id, options = {}) {
+    const node = await this.oms.storage.get(id);
+    if (node.kind !== "file")
+      throw new OmsError(`"${node.name}" e' uma pasta, nao um projecto.`, "invalid_request");
+    const { stream, size } = await this.oms.storage.downloadStream(id, {
+      ...options.signal === undefined ? {} : { signal: options.signal }
+    });
+    const total = size ?? node.size;
+    const chunks = [];
+    let loaded = 0;
+    options.onProgress?.({ phase: "download", loaded: 0, total });
+    const reader = stream.getReader();
+    for (;; ) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      if (!value)
+        continue;
+      chunks.push(value);
+      loaded += value.byteLength;
+      options.onProgress?.({ phase: "download", loaded, total });
+    }
+    const data = new Uint8Array(loaded);
+    let at = 0;
+    for (const chunk of chunks) {
+      data.set(chunk, at);
+      at += chunk.byteLength;
+    }
+    return { data, name: node.name, project: toProject(node) };
+  }
+  async downloadUrl(id) {
+    const node = await this.oms.storage.get(id);
+    if (node.kind !== "file")
+      throw new OmsError(`"${node.name}" e' uma pasta, nao um projecto.`, "invalid_request");
+    return { url: await this.oms.storage.downloadUrl(id), project: toProject(node) };
+  }
+  async transcribe(media, options = {}) {
+    const run = await this.oms.tools.transcription.run({
+      audio: toFileInput(media),
+      ...options.language === undefined ? {} : { language: options.language }
+    }, waitOptions(options));
+    if (run.status === "failed")
+      throw new OmsError(`A transcricao falhou: ${run.error ?? "o servidor nao deu razao"}.`, "server_error");
+    let cues = [];
+    if (run.srt_url) {
+      const srt = await fetchToolArtifact(this.oms.http, run.srt_url, {
+        ...options.signal === undefined ? {} : { signal: options.signal }
+      });
+      cues = parseSrt(await srt.text());
+    }
+    const language = run.detected_language ?? run.language ?? undefined;
+    return {
+      id: run.id,
+      text: run.text ?? cues.map((c) => c.text).join(" "),
+      ...language === undefined ? {} : { language },
+      cues,
+      words: wordsFromCues(cues),
+      approximate: true,
+      durationSeconds: run.duration_seconds
+    };
+  }
+  async captionsUpload(video, options = {}) {
+    const input = toFileInput({ ...video, size: sizeOf(video) });
+    const size = captionUploadSize(input);
+    if (this.usesOAuth && size !== undefined && size > CAPTION_CHUNKED_THRESHOLD)
+      throw new OmsError(`O video tem ${(size / 1048576).toFixed(0)} MiB e o upload por partes das captions nao aceita tokens OAuth ` + `(limitacao do backend). Renderiza mais pequeno (crf mais alto) ou fica abaixo de ${CAPTION_CHUNKED_THRESHOLD / 1048576} MiB.`, "unsupported");
+    return this.oms.tools.captions.upload({ video: input }, {
+      ...options.onProgress === undefined ? {} : { onProgress: options.onProgress },
+      ...options.signal === undefined ? {} : { signal: options.signal }
+    });
+  }
+  async captionsTranscribe(video, options = {}) {
+    const uploaded = await this.captionsUpload(video, options);
+    return this.captionsTranscribeJob(uploaded, options);
+  }
+  async captionsTranscribeJob(job, options = {}) {
+    const start = options.start ?? 0;
+    const end = options.end ?? job.duration;
+    const done = await this.oms.tools.captions.transcribe(job.id, { start, end, ...options.language === undefined ? {} : { language: options.language } }, waitOptions(options));
+    if (done.status === "failed")
+      throw new OmsError(`A transcricao das captions falhou: ${done.error ?? "o servidor nao deu razao"}.`, "server_error");
+    return { job: done, words: done.words ?? [] };
+  }
+  async captionsRender(jobId, options = {}) {
+    const rendered = await this.oms.tools.captions.render(jobId, {
+      ...options.words === undefined ? {} : { words: options.words },
+      ...options.style === undefined ? {} : { style: options.style }
+    }, waitOptions(options));
+    if (rendered.status === "failed")
+      throw new OmsError(`A render das captions falhou: ${rendered.error ?? "o servidor nao deu razao"}.`, "server_error");
+    const output = await fetchToolArtifact(this.oms.http, this.oms.tools.captions.outputUrl(rendered), {
+      ...options.signal === undefined ? {} : { signal: options.signal }
+    });
+    return { job: rendered, output };
+  }
+  async captions(video, options = {}) {
+    const uploaded = await this.captionsUpload(video, options);
+    let words = options.words;
+    let job = uploaded;
+    if (!words || words.length === 0) {
+      const transcribed = await this.captionsTranscribeJob(uploaded, options);
+      job = transcribed.job;
+      words = transcribed.words;
+    }
+    if (words.length === 0)
+      throw new OmsError("Nao ha' palavras para legendar: a transcricao veio vazia.", "invalid_request");
+    const rendered = await this.captionsRender(job.id, {
+      ...options,
+      words
+    });
+    if (!options.keepJob) {
+      try {
+        await this.oms.tools.captions.delete(job.id);
+      } catch {}
+    }
+    return { job: rendered.job, words, output: rendered.output };
+  }
+}
+var waitOptions = (options) => ({
+  ...options.onProgress === undefined ? {} : { onProgress: options.onProgress },
+  ...options.signal === undefined ? {} : { signal: options.signal },
+  ...options.waitTimeoutMs === undefined ? {} : { waitTimeoutMs: options.waitTimeoutMs }
+});
+var bodyError = (body) => typeof body === "object" && body !== null && typeof body.error === "string" ? body.error : undefined;
+var bodyMessage = (body) => typeof body === "object" && body !== null && typeof body.message === "string" ? body.message : undefined;
+var sessionFrom = (set) => {
+  if (!set.idToken)
+    throw new OmsError("O grant nao trouxe id token; foi pedido sem `openid`?", "invalid_request");
+  const claims = decodeIdToken(set.idToken);
+  return {
+    sub: claims.sub,
+    scopes: scopesOf(set),
+    ...set.expiresAt === undefined ? {} : { expiresAt: set.expiresAt },
+    ...typeof claims.preferred_username === "string" ? { handle: claims.preferred_username } : {},
+    ...typeof claims.email === "string" ? { email: claims.email } : {}
+  };
+};
+var cloudCaptionStyle = (style, frame) => {
+  const rgb = (hex) => {
+    if (!hex)
+      return;
+    const m = /^#?([0-9a-f]{6})$/i.exec(hex.trim());
+    if (!m)
+      return;
+    const n2 = parseInt(m[1], 16);
+    return [n2 >> 16 & 255, n2 >> 8 & 255, n2 & 255];
+  };
+  const out = {};
+  if (style.fontScale !== undefined && frame.height > 0)
+    out.fontscale = Math.min(0.09, Math.max(0.03, style.fontScale * frame.width / frame.height));
+  if (style.strokeScale !== undefined)
+    out.stroke_factor = Math.min(0.3, Math.max(0, style.strokeScale));
+  if (style.pos !== undefined)
+    out.pos = Math.min(0.9, Math.max(0.3, style.pos));
+  if (style.maxWords !== undefined)
+    out.max_words = Math.min(6, Math.max(1, Math.round(style.maxWords)));
+  if (style.gap !== undefined)
+    out.gap = Math.min(1, Math.max(0.1, style.gap));
+  const yellow = rgb(style.highlight);
+  const white = rgb(style.color);
+  const stroke = rgb(style.stroke);
+  if (yellow)
+    out.yellow = yellow;
+  if (white)
+    out.white = white;
+  if (stroke)
+    out.stroke = stroke;
+  return out;
+};
+var describeCloudError = (e) => {
+  if (e instanceof OmsDeviceExpiredError)
+    return "O codigo expirou antes de ser aprovado. Volta a entrar.";
+  if (e instanceof OmsDeviceDeniedError)
+    return "A autorizacao foi recusada no browser.";
+  const scope = readInsufficientScope(e);
+  if (scope) {
+    return scope.required.length ? `A sessao nao tem os escopos ${scope.required.join(", ")}. Sai e volta a entrar.` : "Esta rota nao aceita tokens OAuth (limitacao do backend).";
+  }
+  if (e instanceof OmsApiError && e.status === 403 && bodyError(e.body) === "insufficient_scope")
+    return `Esta rota precisa de um escopo que a sessao nao tem, ou nao aceita tokens OAuth: ${bodyMessage(e.body) ?? e.message}`;
+  if (e instanceof OmsAuthError) {
+    const said = bodyMessage(e.body) ?? bodyError(e.body) ?? e.message;
+    const where = e.url ? ` em ${e.method ?? ""} ${e.url.replace(/^https?:\/\/[^/]+/, "")}`.trimEnd() : "";
+    return `O servidor recusou a credencial (${e.status}${where})${said ? `: ${said}` : ""}. Se a sessao expirou ou foi revogada, volta a entrar (omsv cloud login).`;
+  }
+  if (e instanceof OmsQuotaError)
+    return e.retryAfterMs ? `Demasiados pedidos; tenta daqui a ${Math.ceil(e.retryAfterMs / 1000)}s.` : "A quota diaria desta ferramenta esgotou-se.";
+  if (e instanceof OmsTimeoutError)
+    return e.code === "aborted" ? "Cancelado." : "O servidor demorou demasiado a responder.";
+  if (e instanceof OmsNetworkError)
+    return `Sem ligacao a ${"url" in e && e.url ? e.url : "API"}: ${e.message}`;
+  if (e instanceof OmsApiError && e.status === 413)
+    return "O ficheiro e' grande de mais para esta rota.";
+  if (e instanceof Error) {
+    if ("error" in e && e.error === "invalid_client")
+      return `O client_id nao esta' registado no servidor de autorizacao. ${e.message}`;
+    return e.message;
+  }
+  return String(e);
+};
+// src/cloud/store.ts
+var CREDENTIALS_VERSION = 1;
+var parseStoredCredentials = (text) => {
+  if (!text)
+    return null;
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (typeof raw !== "object" || raw === null)
+    return null;
+  const rec = raw;
+  if (rec.version !== CREDENTIALS_VERSION)
+    return null;
+  if (typeof rec.baseUrl !== "string" || typeof rec.clientId !== "string")
+    return null;
+  const tokens = rec.tokens;
+  if (typeof tokens !== "object" || tokens === null)
+    return null;
+  const t = tokens;
+  if (typeof t.accessToken !== "string" || t.accessToken.length === 0)
+    return null;
+  return {
+    version: 1,
+    baseUrl: rec.baseUrl,
+    clientId: rec.clientId,
+    tokens: {
+      accessToken: t.accessToken,
+      tokenType: typeof t.tokenType === "string" ? t.tokenType : "Bearer",
+      ...typeof t.refreshToken === "string" ? { refreshToken: t.refreshToken } : {},
+      ...typeof t.idToken === "string" ? { idToken: t.idToken } : {},
+      ...typeof t.expiresAt === "number" ? { expiresAt: t.expiresAt } : {},
+      ...typeof t.scope === "string" ? { scope: t.scope } : {}
+    }
+  };
+};
+var stringTokenStore = (inner, identity) => {
+  const mine = (stored) => stored !== null && stored.baseUrl === identity.baseUrl && stored.clientId === identity.clientId;
+  return {
+    async load() {
+      const stored = parseStoredCredentials(await inner.load());
+      return mine(stored) ? stored.tokens : null;
+    },
+    async save(tokens) {
+      const stored = { version: 1, ...identity, tokens };
+      await inner.save(JSON.stringify(stored, null, 2));
+    },
+    async clear() {
+      const text = await inner.load();
+      if (text === null)
+        return;
+      const stored = parseStoredCredentials(text);
+      if (stored === null || mine(stored))
+        await inner.clear();
+    }
+  };
+};
+
+// src/cloud/index.ts
+import {
+  DEFAULT_BASE_URL,
+  memoryTokenStore,
+  OmsApiError as OmsApiError2,
+  OmsAuthError as OmsAuthError2,
+  OmsError as OmsError2,
+  OmsNetworkError as OmsNetworkError2,
+  OmsQuotaError as OmsQuotaError2,
+  OmsTimeoutError as OmsTimeoutError2
+} from "@omelhorsite/sdk";
+export {
+  wordsFromCues,
+  unpackProject,
+  timelineWords,
+  stringTokenStore,
+  sourceSpans,
+  sliceProject,
+  sliceClip,
+  shadowMargin,
+  sessionFrom,
+  remapWords,
+  projectDuration,
+  parseStoredCredentials,
+  parseSrt,
+  packProject,
+  memoryTokenStore,
+  makeFlashClip,
+  isZipData,
+  hexToYuv,
+  groupWords,
+  flashStateAt,
+  flashGlowReach,
+  flashGlowAtRadius,
+  flashGlowAt,
+  flashGeqExpr,
+  flashEnvelope,
+  flashCutTime,
+  flashBandOffset,
+  flashBandOf,
+  findAsset,
+  fadeFactor,
+  emptyProject,
+  describeCloudError,
+  computePlacement,
+  compile,
+  cloudCaptionStyle,
+  captionStates,
+  assetEntryName,
+  SHADOW_OPACITY,
+  SHADOW_DROP,
+  RESOLUTION_PRESETS,
+  PROJECT_EXTENSION,
+  PROJECTS_FOLDER,
+  OmsTimeoutError2 as OmsTimeoutError,
+  OmsQuotaError2 as OmsQuotaError,
+  OmsNetworkError2 as OmsNetworkError,
+  OmsError2 as OmsError,
+  OmsAuthError2 as OmsAuthError,
+  OmsApiError2 as OmsApiError,
+  OMS_VIDEO_SCOPES,
+  OMSV_SCHEMA,
+  FLASH_WAVE_SPEED,
+  FLASH_STRIPS,
+  FLASH_CUT_AT,
+  DEFAULT_FLASH_DURATION,
+  DEFAULT_FLASH,
+  DEFAULT_CLIENT_ID,
+  DEFAULT_CAPTION_STYLE,
+  DEFAULT_BASE_URL,
+  Cloud,
+  CREDENTIALS_VERSION
+};