shorts-maker 0.3.0

package/src/jobs/store.ts

@@ -0,0 +1,390 @@
+// Job registry: an in-memory working set (for live SSE) durably backed by SQLite.
+
+import { join } from "node:path";
+import { mkdirSync } from "node:fs";
+import { rm, mkdir, rename } from "node:fs/promises";
+import { Database } from "bun:sqlite";
+import { run, type PartRow, type PublishInfo, type RunOptions } from "../pipeline/pipeline.ts";
+import { isOverlayPosition, type OverlayPosition } from "../pipeline/overlay.ts";
+import { downloadVideo } from "../pipeline/download.ts";
+import { OUTPUT_DIR, UPLOADS_DIR } from "../paths.ts";
+import { uniqueName } from "../files.ts";
+
+/**
+ * Where an in-progress URL download is staged. Dot-prefixed and a directory, so it never
+ * shows up in the uploads library listing (which lists plain video files only).
+ */
+export const stagingDir = (jobId: string): string => join(UPLOADS_DIR, `.dl_${jobId}`);
+
+export type JobStatus = "running" | "done" | "error";
+
+export interface Job {
+  id: string;
+  video: string; // absolute-ish path to source (empty until a URL job downloads it)
+  /** When set, the source is fetched from this link (via yt-dlp) before splitting. */
+  sourceUrl?: string;
+  videoName: string;
+  title?: string;
+  partLen: number;
+  numHashtags: number;
+  hashtags?: string[];
+  /** Where the burned-in "PART 2" badge sits, or undefined when the job has no overlay. */
+  overlay?: OverlayPosition;
+  status: JobStatus;
+  createdAt: number;
+  finishedAt?: number;
+  outDir: string;
+  logs: string[];
+  error?: string;
+  parts: PartRow[];
+}
+
+/** What a browser sees — same as Job but logs are streamed separately, kept light here. */
+export type JobSummary = Omit<Job, "logs" | "hashtags">;
+
+type Sub = (ev: JobEvent) => void;
+export type JobEvent =
+  | { type: "log"; line: string }
+  | { type: "status"; status: JobStatus; error?: string; parts?: PartRow[] };
+
+const DB_FILE = join(OUTPUT_DIR, "jobs.db");
+const LEGACY_JSON = join(OUTPUT_DIR, ".jobs.json");
+
+// ---- SQLite persistence --------------------------------------------------
+
+mkdirSync(OUTPUT_DIR, { recursive: true });
+const db = new Database(DB_FILE, { create: true });
+db.exec("PRAGMA journal_mode = WAL"); // faster concurrent reads/writes
+db.exec(`
+  CREATE TABLE IF NOT EXISTS jobs (
+    id          TEXT PRIMARY KEY,
+    video       TEXT NOT NULL,
+    videoName   TEXT NOT NULL,
+    title       TEXT,
+    partLen     INTEGER NOT NULL,
+    numHashtags INTEGER NOT NULL,
+    hashtags    TEXT,          -- JSON array
+    status      TEXT NOT NULL,
+    createdAt   INTEGER NOT NULL,
+    finishedAt  INTEGER,
+    outDir      TEXT NOT NULL,
+    ephemeral   INTEGER,       -- 0 | 1
+    logs        TEXT,          -- JSON array
+    error       TEXT,
+    parts       TEXT,          -- JSON array
+    overlay     TEXT           -- OverlayPosition, NULL when the job has no badge
+  )
+`);
+
+// Bring a database created before part badges existed up to the current shape.
+const columns = new Set((db.query("PRAGMA table_info(jobs)").all() as { name: string }[]).map((c) => c.name));
+if (!columns.has("overlay")) db.exec("ALTER TABLE jobs ADD COLUMN overlay TEXT");
+
+interface Row {
+  id: string;
+  video: string;
+  videoName: string;
+  title: string | null;
+  partLen: number;
+  numHashtags: number;
+  hashtags: string | null;
+  status: JobStatus;
+  createdAt: number;
+  finishedAt: number | null;
+  outDir: string;
+  ephemeral: number;  // legacy column, always 0 now
+  logs: string | null;
+  error: string | null;
+  parts: string | null;
+  overlay: string | null;
+}
+
+const saveStmt = db.query(`
+  INSERT OR REPLACE INTO jobs
+    (id, video, videoName, title, partLen, numHashtags, hashtags, status,
+     createdAt, finishedAt, outDir, ephemeral, logs, error, parts, overlay)
+  VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+`);
+const delStmt = db.query("DELETE FROM jobs WHERE id = ?");
+const allStmt = db.query("SELECT * FROM jobs ORDER BY createdAt DESC");
+const countStmt = db.query("SELECT COUNT(*) AS n FROM jobs");
+
+function saveJob(j: Job): void {
+  saveStmt.run(
+    j.id,
+    j.video,
+    j.videoName,
+    j.title ?? null,
+    j.partLen,
+    j.numHashtags,
+    j.hashtags ? JSON.stringify(j.hashtags) : null,
+    j.status,
+    j.createdAt,
+    j.finishedAt ?? null,
+    j.outDir,
+    0, // legacy `ephemeral` column — sources now live on in uploads/
+    JSON.stringify(j.logs),
+    j.error ?? null,
+    JSON.stringify(j.parts),
+    j.overlay ?? null,
+  );
+}
+
+function rowToJob(r: Row): Job {
+  return {
+    id: r.id,
+    video: r.video,
+    videoName: r.videoName,
+    title: r.title ?? undefined,
+    partLen: r.partLen,
+    numHashtags: r.numHashtags,
+    hashtags: r.hashtags ? (JSON.parse(r.hashtags) as string[]) : undefined,
+    overlay: isOverlayPosition(r.overlay) ? r.overlay : undefined,
+    status: r.status,
+    createdAt: r.createdAt,
+    finishedAt: r.finishedAt ?? undefined,
+    outDir: r.outDir,
+    logs: r.logs ? (JSON.parse(r.logs) as string[]) : [],
+    error: r.error ?? undefined,
+    parts: r.parts ? (JSON.parse(r.parts) as PartRow[]) : [],
+  };
+}
+
+// ---- In-memory working set ----------------------------------------------
+
+const jobs = new Map<string, Job>();
+const subs = new Map<string, Set<Sub>>();
+/** Abort handles for in-flight jobs, so deleting one can kill its download/split. */
+const running = new Map<string, AbortController>();
+let loaded = false;
+
+export async function load(): Promise<void> {
+  if (loaded) return;
+  loaded = true;
+
+  // One-time migration from the legacy JSON store, then retire it.
+  const dbEmpty = (countStmt.get() as { n: number }).n === 0;
+  if (dbEmpty && (await Bun.file(LEGACY_JSON).exists())) {
+    try {
+      const arr = JSON.parse(await Bun.file(LEGACY_JSON).text()) as Job[];
+      db.transaction((rows: Job[]) => rows.forEach(saveJob))(arr);
+      await rm(LEGACY_JSON, { force: true }).catch(() => {});
+    } catch {
+      /* leave a malformed legacy file in place for inspection */
+    }
+  } else {
+    await rm(LEGACY_JSON, { force: true }).catch(() => {});
+  }
+
+  // Hydrate memory; a job that was mid-run when the server stopped is dead.
+  for (const r of allStmt.all() as Row[]) {
+    const j = rowToJob(r);
+    let dirty = false;
+    if (j.status === "running") {
+      j.status = "error";
+      j.error = "Interrupted (server restarted).";
+      dirty = true;
+    }
+    // A publish that was still uploading when the server stopped can never finish.
+    for (const part of j.parts) {
+      for (const [platform, info] of Object.entries(part.published ?? {})) {
+        if (info.status === "pending") {
+          part.published![platform] = { status: "error", error: "Interrupted (server restarted).", at: info.at };
+          dirty = true;
+        }
+      }
+    }
+    if (dirty) saveJob(j);
+    jobs.set(j.id, j);
+  }
+}
+
+function emit(id: string, ev: JobEvent): void {
+  // A disconnected SSE subscriber must never throw into (and kill) the running job.
+  for (const fn of subs.get(id) ?? []) {
+    try {
+      fn(ev);
+    } catch {
+      /* dead stream — ignore */
+    }
+  }
+}
+
+export function subscribe(id: string, fn: Sub): () => void {
+  let set = subs.get(id);
+  if (!set) subs.set(id, (set = new Set()));
+  set.add(fn);
+  return () => set!.delete(fn);
+}
+
+/** Filesystem-safe timestamp for unique output dirs, e.g. 20260709-153012. */
+export function stamp(): string {
+  const d = new Date();
+  const p = (n: number) => String(n).padStart(2, "0");
+  return (
+    `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}` +
+    `-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`
+  );
+}
+
+export function summary(j: Job): JobSummary {
+  const { logs: _logs, hashtags: _tags, ...rest } = j;
+  return rest;
+}
+
+export function list(): JobSummary[] {
+  return [...jobs.values()].sort((a, b) => b.createdAt - a.createdAt).map(summary);
+}
+
+export function get(id: string): Job | undefined {
+  return jobs.get(id);
+}
+
+/** The publish lifecycle for one platform on one part (undefined = never attempted). */
+export function publishState(jobId: string, file: string, platform: string): PublishInfo | undefined {
+  return jobs.get(jobId)?.parts.find((p) => p.file === file)?.published?.[platform];
+}
+
+/** Set (and durably persist) a part's publish state for a platform. Returns false if not found. */
+export function setPublishState(jobId: string, file: string, platform: string, info: PublishInfo): boolean {
+  const job = jobs.get(jobId);
+  if (!job) return false;
+  const part = job.parts.find((p) => p.file === file);
+  if (!part) return false;
+  part.published = { ...(part.published ?? {}), [platform]: info };
+  saveJob(job);
+  return true;
+}
+
+/** Update a part's caption — in memory, in the DB, and in its paste-ready .txt on disk. */
+export async function setCaption(jobId: string, file: string, caption: string): Promise<boolean> {
+  const job = jobs.get(jobId);
+  const part = job?.parts.find((p) => p.file === file);
+  if (!job || !part) return false;
+  part.caption = caption;
+  saveJob(job);
+  const txt = join(job.outDir, "parts", file.replace(/\.[^.]+$/, ".txt"));
+  await Bun.write(txt, caption + "\n").catch(() => {});
+  return true;
+}
+
+/** Forget a part's publish record for a platform (e.g. after deleting the post). */
+export function clearPublishState(jobId: string, file: string, platform: string): boolean {
+  const job = jobs.get(jobId);
+  const part = job?.parts.find((p) => p.file === file);
+  if (!job || !part?.published?.[platform]) return false;
+  delete part.published[platform];
+  saveJob(job);
+  return true;
+}
+
+export async function remove(id: string): Promise<boolean> {
+  const j = jobs.get(id);
+  if (!j) return false;
+  // Stop any in-flight download/split first, then forget the job. Deleting from `jobs` here
+  // (synchronously, before the aborted task unwinds) is what stops execute() from re-saving it.
+  running.get(id)?.abort();
+  jobs.delete(id);
+  subs.delete(id);
+  delStmt.run(id);
+  await rm(j.outDir, { recursive: true, force: true }).catch(() => {});
+  // The source video stays in uploads/ — it's a reusable library file with its own page.
+  // Only the in-progress download staging (if any) gets scrapped.
+  await rm(stagingDir(id), { recursive: true, force: true }).catch(() => {});
+  return true;
+}
+
+export interface CreateOptions {
+  /** Local source path (uploads). Mutually exclusive with `url`. */
+  video?: string;
+  /** Remote source link — downloaded via yt-dlp before splitting. */
+  url?: string;
+  videoName: string;
+  outDir: string;
+  title?: string;
+  partLen?: number;
+  numHashtags?: number;
+  hashtags?: string[];
+  /** Burn a part badge in at this position. Omit for no overlay (and a much faster cut). */
+  overlay?: OverlayPosition;
+}
+
+export async function create(opts: CreateOptions): Promise<Job> {
+  const job: Job = {
+    id: crypto.randomUUID().slice(0, 8),
+    video: opts.video ?? "",
+    sourceUrl: opts.url,
+    videoName: opts.videoName,
+    title: opts.title,
+    partLen: opts.partLen ?? 900,
+    numHashtags: opts.numHashtags ?? 8,
+    hashtags: opts.hashtags,
+    overlay: opts.overlay,
+    status: "running",
+    createdAt: Date.now(),
+    outDir: opts.outDir,
+    logs: [],
+    parts: [],
+  };
+  jobs.set(job.id, job);
+  saveJob(job);
+  void execute(job);
+  return job;
+}
+
+async function execute(job: Job): Promise<void> {
+  const onLog = (line: string) => {
+    job.logs.push(line);
+    emit(job.id, { type: "log", line });
+  };
+  const controller = new AbortController();
+  running.set(job.id, controller);
+  const dlDir = stagingDir(job.id); // in-progress download only; removed in `finally`
+  try {
+    // A URL source is fetched first; its progress streams into the same live log. Once it
+    // lands we move it out of staging into uploads/, so it joins the reusable library.
+    if (job.sourceUrl) {
+      const dl = await downloadVideo(job.sourceUrl, dlDir, onLog, controller.signal);
+      await mkdir(UPLOADS_DIR, { recursive: true });
+      const name = await uniqueName(UPLOADS_DIR, dl.name);
+      const dest = join(UPLOADS_DIR, name);
+      await rename(dl.path, dest);
+      job.video = dest;
+      if (!job.title) job.videoName = name; // show the real title in history
+      saveJob(job);
+    }
+
+    const manifest = await run({
+      video: job.video,
+      outDir: job.outDir,
+      title: job.title,
+      partLen: job.partLen,
+      numHashtags: job.numHashtags,
+      hashtags: job.hashtags,
+      overlay: job.overlay,
+      onLog,
+      signal: controller.signal,
+    });
+    job.parts = manifest.parts;
+    job.status = "done";
+    job.finishedAt = Date.now();
+    emit(job.id, { type: "status", status: "done", parts: job.parts });
+  } catch (err) {
+    // If the job was deleted mid-run it's already gone — the error is just the abort unwinding.
+    if (jobs.has(job.id)) {
+      const e = err as Error;
+      job.status = "error";
+      job.error = `${e.name}: ${e.message}`;
+      job.finishedAt = Date.now();
+      job.logs.push(`✗ ${job.error}`);
+      emit(job.id, { type: "log", line: `✗ ${job.error}` });
+      emit(job.id, { type: "status", status: "error", error: job.error });
+    }
+  } finally {
+    running.delete(job.id);
+    // The source video is kept in uploads/ for reuse — only staging is disposable.
+    await rm(dlDir, { recursive: true, force: true }).catch(() => {});
+    // Never re-persist a job that was deleted while running (would resurrect it on restart).
+    if (jobs.has(job.id)) saveJob(job);
+  }
+}

package/src/paths.ts

@@ -0,0 +1,23 @@
+// Two distinct roots the app pulls from:
+//   • PKG_DIR  — where the package is installed (read-only assets: the built frontend,
+//                the default hashtags list). Anchored to this file's location.
+//   • DATA_DIR — where the *user's* stuff is written (jobs, uploads, credentials).
+//                Defaults to the folder they run the command in, so `bunx shorts-maker`
+//                behaves like a normal project tool (à la vite/next) instead of writing
+//                into the global install cache. Override with SHORTS_MAKER_DIR.
+
+import { join } from "node:path";
+
+export const PKG_DIR = join(import.meta.dir, "..");
+export const DATA_DIR = process.env.SHORTS_MAKER_DIR || process.cwd();
+
+export const OUTPUT_DIR = join(DATA_DIR, "output");
+export const UPLOADS_DIR = join(DATA_DIR, "uploads");
+export const CONFIG_DIR = join(DATA_DIR, "config");
+
+/** The pre-built frontend served in production (created by `bun run build`). */
+export const DIST_DIR = join(PKG_DIR, "dist");
+
+/** Hashtags list: a user-provided one in their folder wins over the packaged default. */
+export const packagedHashtags = join(PKG_DIR, "hashtags.txt");
+export const userHashtags = join(DATA_DIR, "hashtags.txt");

package/src/pipeline/download.ts

@@ -0,0 +1,201 @@
+// Fetch a source video from a URL via yt-dlp — covers YouTube, Dailymotion, and direct
+// video links (its generic extractor handles plain files too). yt-dlp shells out to ffmpeg
+// to merge best video+audio, which is already a project requirement.
+
+import { readdir, mkdir, rm } from "node:fs/promises";
+import { join, extname } from "node:path";
+import { MediaError } from "./media.ts";
+
+const VIDEO_EXTS = new Set([".mp4", ".mkv", ".mov", ".webm", ".m4v", ".avi", ".ts", ".flv"]);
+
+// Robustness flags applied to every attempt. --extractor-retries covers the "Unable to
+// download webpage: HTTP 429" case; --retries/--fragment-retries cover flaky data transfer.
+const BASE_ARGS = [
+  "--no-playlist", // a link inside a playlist grabs just that video
+  "--newline", // progress on its own line so it streams cleanly to the log
+  "--no-part",
+  "-f",
+  "bv*+ba/b", // best video+audio, or best single stream
+  "--merge-output-format",
+  "mp4",
+  "--extractor-retries",
+  "3",
+  "--retries",
+  "5",
+  "--fragment-retries",
+  "10",
+];
+
+// Errors worth escalating to the next strategy for (YouTube bot wall / rate limits).
+// Anything else (bad URL, private video, unsupported site) fails fast — no point retrying.
+const RETRYABLE = /sign in to confirm|not a bot|HTTP Error 429|too many requests|temporarily|rate.?limit/i;
+
+export interface Downloaded {
+  path: string;
+  name: string;
+}
+
+/**
+ * Wrap `onLog` so yt-dlp's flood of `[download] NN.N%` lines is thinned to at most one per
+ * whole percent AND one per ~400ms — a slow download logs roughly per-percent, a fast/small
+ * one logs a handful of coarse steps. Every non-progress line (stage changes, warnings)
+ * passes through untouched. yt-dlp emits two streams (video then audio); the percent drop
+ * between them resets the counter so the second stream is shown too.
+ */
+function throttleProgress(onLog: (line: string) => void): (line: string) => void {
+  let lastPct = -1;
+  let lastAt = 0;
+  let prevRaw = -1;
+  return (line) => {
+    const m = line.match(/^\[download\]\s+([\d.]+)%/);
+    if (!m) {
+      onLog(line);
+      return;
+    }
+    const raw = parseFloat(m[1]!);
+    if (raw + 0.5 < prevRaw) lastPct = -1; // percent went backwards → a new stream started
+    prevRaw = raw;
+    const pct = Math.floor(raw);
+    const now = Date.now();
+    if (raw >= 100 || (pct > lastPct && now - lastAt >= 400)) {
+      lastPct = pct;
+      lastAt = now;
+      onLog(line);
+    }
+  };
+}
+
+/** Read a subprocess stream line-by-line, forwarding each line to `onLine`. */
+async function pumpLines(stream: ReadableStream<Uint8Array>, onLine: (line: string) => void): Promise<void> {
+  const reader = stream.getReader();
+  const dec = new TextDecoder();
+  let buf = "";
+  for (;;) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buf += dec.decode(value, { stream: true });
+    for (let nl = buf.indexOf("\n"); nl >= 0; nl = buf.indexOf("\n")) {
+      const line = buf.slice(0, nl).trimEnd();
+      buf = buf.slice(nl + 1);
+      if (line) onLine(line);
+    }
+  }
+  if (buf.trim()) onLine(buf.trim());
+}
+
+interface Strategy {
+  label: string;
+  args: string[];
+}
+
+/**
+ * Ordered attempts. If the user pointed us at browser cookies we try those first (the real
+ * fix for YouTube's "confirm you're not a bot" wall). Otherwise we start anonymous and, on a
+ * bot/rate-limit failure, escalate through alternate player clients that sometimes slip past.
+ */
+function strategies(): Strategy[] {
+  const list: Strategy[] = [];
+  const browser = process.env.SHORTS_MAKER_COOKIES_FROM_BROWSER?.trim();
+  const cookieFile = process.env.SHORTS_MAKER_COOKIES?.trim();
+  if (browser) list.push({ label: `${browser} cookies`, args: ["--cookies-from-browser", browser] });
+  else if (cookieFile) list.push({ label: "cookies file", args: ["--cookies", cookieFile] });
+  list.push({ label: "default", args: [] });
+  list.push({ label: "tv client", args: ["--extractor-args", "youtube:player_client=tv"] });
+  list.push({ label: "ios client", args: ["--extractor-args", "youtube:player_client=ios"] });
+  return list;
+}
+
+/** Run one yt-dlp attempt, streaming progress; return its exit code + last stderr lines. */
+async function attempt(
+  args: string[],
+  onLog: (line: string) => void,
+  signal?: AbortSignal,
+): Promise<{ code: number; errTail: string[] }> {
+  const proc = Bun.spawn(["yt-dlp", ...args], { stdout: "pipe", stderr: "pipe" });
+  const onAbort = () => proc.kill(); // deleting the job kills the download
+  if (signal?.aborted) proc.kill();
+  else signal?.addEventListener("abort", onAbort, { once: true });
+  const errTail: string[] = [];
+  const emit = throttleProgress(onLog);
+  try {
+    await Promise.all([
+      pumpLines(proc.stdout, emit),
+      pumpLines(proc.stderr, (line) => {
+        errTail.push(line); // keep raw (unthrottled) stderr for error diagnostics
+        if (errTail.length > 8) errTail.shift();
+        emit(line);
+      }),
+    ]);
+    return { code: await proc.exited, errTail };
+  } finally {
+    signal?.removeEventListener("abort", onAbort);
+  }
+}
+
+/** Turn a failed run's stderr into a message that points at the actual fix. */
+function failureMessage(errTail: string[]): string {
+  const joined = errTail.join("\n");
+  let msg = `Download failed:\n${joined || "no output"}`;
+  if (/sign in to confirm|not a bot/i.test(joined)) {
+    msg +=
+      "\n\nYouTube is blocking anonymous downloads for this video. Use your browser's login: " +
+      "start the app with SHORTS_MAKER_COOKIES_FROM_BROWSER set to your browser " +
+      "(chrome, safari, firefox, edge, or brave), or serve with " +
+      "`--cookies-from-browser <browser>`, then retry.";
+  } else if (/429|too many requests/i.test(joined)) {
+    msg += "\n\nYouTube is rate-limiting you (HTTP 429). Wait a few minutes, then retry.";
+  }
+  return msg;
+}
+
+/**
+ * Download `url` into `destDir`, streaming yt-dlp's progress to `onLog`. Tries a sequence of
+ * strategies (see `strategies`), retrying only on YouTube's bot-wall / rate-limit errors and
+ * failing fast on anything else. Returns the resulting local file.
+ */
+export async function downloadVideo(
+  url: string,
+  destDir: string,
+  onLog: (line: string) => void,
+  signal?: AbortSignal,
+): Promise<Downloaded> {
+  if (!Bun.which("yt-dlp")) {
+    throw new MediaError(
+      "`yt-dlp` was not found on PATH — it's needed to import from a link. " +
+        "Install it (e.g. `brew install yt-dlp`, or `pip install yt-dlp`), then retry.",
+    );
+  }
+
+  const plan = strategies();
+  let lastErr: string[] = [];
+  for (let i = 0; i < plan.length; i++) {
+    if (signal?.aborted) throw new MediaError("Cancelled.");
+    const s = plan[i]!;
+    // Fresh dir each attempt so a failed run's partial files can't be mistaken for the result.
+    await rm(destDir, { recursive: true, force: true }).catch(() => {});
+    await mkdir(destDir, { recursive: true });
+    onLog(i === 0 ? `⬇ Downloading ${url}` : `↻ Retrying via ${s.label}…`);
+
+    const { code, errTail } = await attempt(
+      [...BASE_ARGS, ...s.args, "-o", join(destDir, "%(title).80B.%(ext)s"), url],
+      onLog,
+      signal,
+    );
+
+    if (signal?.aborted) throw new MediaError("Cancelled.");
+    if (code === 0) {
+      const files = await readdir(destDir);
+      const name =
+        files.find((f) => extname(f).toLowerCase() === ".mp4") ??
+        files.find((f) => VIDEO_EXTS.has(extname(f).toLowerCase()));
+      if (name) return { path: join(destDir, name), name };
+      lastErr = ["yt-dlp reported success but produced no video file."];
+    } else {
+      lastErr = errTail;
+      if (!RETRYABLE.test(errTail.join("\n"))) break; // not a bot/rate error — don't churn
+      if (i < plan.length - 1) await Bun.sleep(3000); // brief backoff before escalating
+    }
+  }
+
+  throw new MediaError(failureMessage(lastErr));
+}