Initial open-source self-hosted Songs2YT edition

app/api/account/api-key/route.ts

@@ -0,0 +1,49 @@
+import { NextResponse } from "next/server";
+import { createUserApiKey, getUserApiKeyStatus, revokeUserApiKey } from "@/lib/api-keys";
+import { hasProFeatures } from "@/lib/edition";
+import { getSessionUser } from "@/lib/session";
+
+async function requireApiKeyAccess() {
+  const user = await getSessionUser();
+  if (!user) {
+    return { error: NextResponse.json({ error: "Unauthorized" }, { status: 401 }), user: null };
+  }
+  if (!hasProFeatures(user.plan)) {
+    return {
+      error: NextResponse.json(
+        { error: "API keys are available on the Pro plan only" },
+        { status: 403 },
+      ),
+      user: null,
+    };
+  }
+  return { error: null, user };
+}
+
+export async function GET() {
+  const { error, user } = await requireApiKeyAccess();
+  if (error || !user) return error!;
+
+  const status = await getUserApiKeyStatus(user.id);
+  return NextResponse.json(status);
+}
+
+export async function POST() {
+  const { error, user } = await requireApiKeyAccess();
+  if (error || !user) return error!;
+
+  const { token, prefix } = await createUserApiKey(user.id);
+  return NextResponse.json({
+    apiKey: token,
+    prefix,
+    message: "Copy this key now. It will not be shown again.",
+  });
+}
+
+export async function DELETE() {
+  const { error, user } = await requireApiKeyAccess();
+  if (error || !user) return error!;
+
+  await revokeUserApiKey(user.id);
+  return NextResponse.json({ ok: true });
+}

app/api/account/api-rate-limit-extension-request/route.ts

@@ -0,0 +1,51 @@
+import { NextRequest, NextResponse } from "next/server";
+import {
+  createQuotaExtensionRequest,
+  EXTENSION_KIND,
+  getQuotaExtensionUsage,
+} from "@/lib/quota-extensions";
+import { hasProFeatures } from "@/lib/edition";
+import { getSessionUser } from "@/lib/session";
+
+export async function GET() {
+  const user = await getSessionUser();
+  if (!user) {
+    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+  }
+  if (!hasProFeatures(user.plan)) {
+    return NextResponse.json({ error: "Pro plan required" }, { status: 403 });
+  }
+
+  const usage = await getQuotaExtensionUsage(user.id, EXTENSION_KIND.API_RATE_LIMIT);
+  return NextResponse.json(usage);
+}
+
+export async function POST(req: NextRequest) {
+  const user = await getSessionUser();
+  if (!user) {
+    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+  }
+  if (!hasProFeatures(user.plan)) {
+    return NextResponse.json({ error: "Pro plan required" }, { status: 403 });
+  }
+
+  let message = "";
+  try {
+    const body = await req.json();
+    if (typeof body.message === "string") message = body.message;
+  } catch {
+    // optional body
+  }
+
+  try {
+    const result = await createQuotaExtensionRequest(
+      user.id,
+      message,
+      EXTENSION_KIND.API_RATE_LIMIT,
+    );
+    return NextResponse.json(result);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "Failed to submit request";
+    return NextResponse.json({ error: msg }, { status: 400 });
+  }
+}

app/api/account/api-rate-limit/route.ts

@@ -0,0 +1,20 @@
+import { NextResponse } from "next/server";
+import { getApiRateLimitStatus } from "@/lib/api-rate-limit";
+import { hasProFeatures } from "@/lib/edition";
+import { getSessionUser } from "@/lib/session";
+
+export async function GET() {
+  const user = await getSessionUser();
+  if (!user) {
+    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+  }
+  if (!hasProFeatures(user.plan)) {
+    return NextResponse.json(
+      { error: "API rate limits are available on the Pro plan only" },
+      { status: 403 },
+    );
+  }
+
+  const status = await getApiRateLimitStatus(user.id);
+  return NextResponse.json(status);
+}

app/api/account/cancel-subscription/route.ts

@@ -0,0 +1,30 @@
+import { NextResponse } from "next/server";
+import { prisma } from "@/lib/db";
+import { getInitialQuotaResetAt } from "@/lib/quota";
+import { getSessionUser } from "@/lib/session";
+
+export async function POST() {
+  const user = await getSessionUser();
+  if (!user) {
+    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+  }
+
+  if (user.plan !== "PREMIUM") {
+    return NextResponse.json({ error: "No active subscription to cancel" }, { status: 400 });
+  }
+
+  await prisma.user.update({
+    where: { id: user.id },
+    data: {
+      plan: "FREE",
+      cardLast4: null,
+      subscribedAt: null,
+      apiKeyHash: null,
+      apiKeyPrefix: null,
+      apiRateLimitBonus: 0,
+      quotaResetAt: getInitialQuotaResetAt(),
+    },
+  });
+
+  return NextResponse.json({ ok: true });
+}

app/api/account/delete/route.ts

@@ -0,0 +1,14 @@
+import { NextResponse } from "next/server";
+import { prisma } from "@/lib/db";
+import { getSessionUser } from "@/lib/session";
+
+export async function POST() {
+  const user = await getSessionUser();
+  if (!user) {
+    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+  }
+
+  await prisma.user.delete({ where: { id: user.id } });
+
+  return NextResponse.json({ ok: true });
+}

app/api/account/quota-extension-request/route.ts

@@ -0,0 +1,36 @@
+import { NextRequest, NextResponse } from "next/server";
+import { createQuotaExtensionRequest, getQuotaExtensionUsage } from "@/lib/quota-extensions";
+import { getSessionUser } from "@/lib/session";
+
+export async function GET() {
+  const user = await getSessionUser();
+  if (!user) {
+    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+  }
+
+  const usage = await getQuotaExtensionUsage(user.id);
+  return NextResponse.json(usage);
+}
+
+export async function POST(req: NextRequest) {
+  const user = await getSessionUser();
+  if (!user) {
+    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+  }
+
+  let message = "";
+  try {
+    const body = await req.json();
+    if (typeof body.message === "string") message = body.message;
+  } catch {
+    // optional body
+  }
+
+  try {
+    const result = await createQuotaExtensionRequest(user.id, message);
+    return NextResponse.json(result);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "Failed to submit request";
+    return NextResponse.json({ error: msg }, { status: 400 });
+  }
+}

app/api/admin/quota-extension-request/[id]/route.ts

@@ -0,0 +1,53 @@
+import { NextRequest, NextResponse } from "next/server";
+import {
+  approveQuotaExtensionRequest,
+  rejectQuotaExtensionRequest,
+} from "@/lib/quota-extensions";
+
+function isAuthorized(req: NextRequest) {
+  const key = process.env.ADMIN_API_KEY;
+  if (!key) return false;
+  const auth = req.headers.get("authorization");
+  return auth === `Bearer ${key}`;
+}
+
+export async function POST(
+  req: NextRequest,
+  { params }: { params: Promise<{ id: string }> },
+) {
+  if (!isAuthorized(req)) {
+    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+  }
+
+  const { id } = await params;
+  let action: "approve" | "reject" = "approve";
+  let bonusQuota: number | undefined;
+  let bonusRateLimit: number | undefined;
+  let adminNote: string | undefined;
+
+  try {
+    const body = await req.json();
+    if (body.action === "reject") action = "reject";
+    if (typeof body.bonusQuota === "number" && Number.isFinite(body.bonusQuota)) {
+      bonusQuota = body.bonusQuota;
+    }
+    if (typeof body.bonusRateLimit === "number" && Number.isFinite(body.bonusRateLimit)) {
+      bonusRateLimit = body.bonusRateLimit;
+    }
+    if (typeof body.adminNote === "string") adminNote = body.adminNote;
+  } catch {
+    // defaults
+  }
+
+  try {
+    if (action === "reject") {
+      await rejectQuotaExtensionRequest(id, adminNote);
+    } else {
+      await approveQuotaExtensionRequest(id, { bonusQuota, bonusRateLimit, adminNote });
+    }
+    return NextResponse.json({ ok: true });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "Failed to process request";
+    return NextResponse.json({ error: msg }, { status: 400 });
+  }
+}

app/api/auth/[...nextauth]/route.ts

@@ -0,0 +1,6 @@
+import NextAuth from "next-auth";
+import { authOptions } from "@/lib/auth";
+
+const handler = NextAuth(authOptions);
+
+export { handler as GET, handler as POST };

app/api/jobs/[id]/route.ts

@@ -0,0 +1,47 @@
+import { NextRequest, NextResponse } from "next/server";
+import { prisma } from "@/lib/db";
+import { requireAuth } from "@/lib/session";
+
+export async function GET(
+  _req: NextRequest,
+  { params }: { params: Promise<{ id: string }> },
+) {
+  const { error, user } = await requireAuth();
+  if (error || !user) return error!;
+
+  const { id } = await params;
+
+  const job = await prisma.job.findFirst({
+    where: { id, userId: user.id },
+    include: {
+      items: {
+        orderBy: { audioFilename: "asc" },
+        select: {
+          id: true,
+          audioFilename: true,
+          title: true,
+          description: true,
+          tags: true,
+          privacy: true,
+          categoryId: true,
+          resolution: true,
+          status: true,
+          youtubeVideoId: true,
+          error: true,
+        },
+      },
+    },
+  });
+
+  if (!job) {
+    return NextResponse.json({ error: "Job not found" }, { status: 404 });
+  }
+
+  return NextResponse.json({
+    id: job.id,
+    status: job.status,
+    createdAt: job.createdAt.toISOString(),
+    completedAt: job.completedAt?.toISOString() ?? null,
+    items: job.items,
+  });
+}

app/api/jobs/route.ts

@@ -0,0 +1,58 @@
+import { NextRequest, NextResponse } from "next/server";
+import { createVideoJob } from "@/lib/jobs/create-job";
+import { prisma } from "@/lib/db";
+import { requireAuth } from "@/lib/session";
+import type { CreateJobPayload } from "@/lib/types";
+
+export const maxDuration = 120;
+
+export async function POST(req: NextRequest) {
+  const { error, user } = await requireAuth();
+  if (error || !user) return error!;
+
+  const body = (await req.json()) as CreateJobPayload;
+
+  try {
+    const job = await createVideoJob(user, body);
+    return NextResponse.json({ jobId: job.id });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to create job";
+    const status = message.includes("Quota exceeded") ? 403 : 400;
+    return NextResponse.json({ error: message }, { status });
+  }
+}
+
+export async function GET(req: NextRequest) {
+  const { error, user } = await requireAuth();
+  if (error || !user) return error!;
+
+  const limit = Math.min(Number(req.nextUrl.searchParams.get("limit")) || 20, 100);
+
+  const jobs = await prisma.job.findMany({
+    where: { userId: user.id },
+    orderBy: { createdAt: "desc" },
+    take: limit,
+    include: {
+      items: {
+        select: {
+          id: true,
+          audioFilename: true,
+          title: true,
+          status: true,
+          youtubeVideoId: true,
+          error: true,
+        },
+      },
+    },
+  });
+
+  return NextResponse.json({
+    jobs: jobs.map((job) => ({
+      id: job.id,
+      status: job.status,
+      createdAt: job.createdAt.toISOString(),
+      completedAt: job.completedAt?.toISOString() ?? null,
+      items: job.items,
+    })),
+  });
+}

app/api/quota/route.ts

@@ -0,0 +1,13 @@
+import { NextResponse } from "next/server";
+import { getQuotaInfo } from "@/lib/quota";
+import { getSessionUser } from "@/lib/session";
+
+export async function GET() {
+  const user = await getSessionUser();
+  if (!user) {
+    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+  }
+
+  const quota = await getQuotaInfo(user.id);
+  return NextResponse.json(quota);
+}

app/api/upload/route.ts

@@ -0,0 +1,29 @@
+import { NextRequest, NextResponse } from "next/server";
+import { saveUploadedFile } from "@/lib/jobs/create-job";
+import { getSessionUser } from "@/lib/session";
+
+export const maxDuration = 120;
+
+export async function POST(req: NextRequest) {
+  const user = await getSessionUser();
+  if (!user) {
+    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+  }
+
+  const formData = await req.formData();
+  const file = formData.get("file") as File | null;
+  const type = formData.get("type") as string | null;
+  const sessionKey = (formData.get("session") as string | null)?.trim() || undefined;
+
+  if (!file || !type || (type !== "image" && type !== "audio")) {
+    return NextResponse.json({ error: "Missing file or type" }, { status: 400 });
+  }
+
+  try {
+    const result = await saveUploadedFile(user.id, file, type, user.plan, { sessionKey });
+    return NextResponse.json(result);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Upload failed";
+    return NextResponse.json({ error: message }, { status: 400 });
+  }
+}

app/api/v1/jobs/[id]/route.ts

@@ -0,0 +1,47 @@
+import { NextRequest, NextResponse } from "next/server";
+import { requirePaidApiUser } from "@/lib/api-auth";
+import { prisma } from "@/lib/db";
+
+export async function GET(
+  _req: NextRequest,
+  { params }: { params: Promise<{ id: string }> },
+) {
+  const { error, user } = await requirePaidApiUser(_req);
+  if (error || !user) return error!;
+
+  const { id } = await params;
+
+  const job = await prisma.job.findFirst({
+    where: { id, userId: user.id },
+    include: {
+      items: {
+        orderBy: { audioFilename: "asc" },
+        select: {
+          id: true,
+          audioFilename: true,
+          title: true,
+          description: true,
+          tags: true,
+          privacy: true,
+          categoryId: true,
+          resolution: true,
+          status: true,
+          youtubeVideoId: true,
+          error: true,
+        },
+      },
+    },
+  });
+
+  if (!job) {
+    return NextResponse.json({ error: "Job not found" }, { status: 404 });
+  }
+
+  return NextResponse.json({
+    id: job.id,
+    status: job.status,
+    createdAt: job.createdAt.toISOString(),
+    completedAt: job.completedAt?.toISOString() ?? null,
+    items: job.items,
+  });
+}

app/api/v1/jobs/batch/route.ts

@@ -0,0 +1,148 @@
+import { NextRequest, NextResponse } from "next/server";
+import { Privacy } from "@prisma/client";
+import { requirePaidApiUser } from "@/lib/api-auth";
+import { createVideoJob, saveUploadedFile } from "@/lib/jobs/create-job";
+import {
+  applyCreatePlaylistToItems,
+  parseCreatePlaylistInput,
+} from "@/lib/jobs/resolve-playlist";
+import { filenameWithoutExtension } from "@/lib/constants";
+import { mapWithConcurrency } from "@/lib/fs-utils";
+import { getPlanLimits } from "@/lib/plans";
+import { checkQuota } from "@/lib/quota";
+import type { CreateJobPayload, CreatePlaylistRequest, ItemMetadata } from "@/lib/types";
+
+export const maxDuration = 300;
+
+type BatchItemInput = Partial<ItemMetadata> & {
+  filename?: string;
+  title?: string;
+};
+
+function defaultMetadata(title: string): ItemMetadata {
+  return {
+    title,
+    description: "",
+    tags: "",
+    privacy: "PUBLIC",
+    categoryId: "10",
+    resolution: "1920x1080",
+    notifySubscribers: true,
+    madeForKids: false,
+    embeddable: true,
+    creativeCommons: false,
+    includeWatermark: false,
+    playlistId: null,
+  };
+}
+
+export async function POST(req: NextRequest) {
+  try {
+    const { error, user } = await requirePaidApiUser(req);
+    if (error || !user) return error!;
+
+    const formData = await req.formData();
+    const image = formData.get("image") as File | null;
+    const audioFiles = formData.getAll("audio").filter((f): f is File => f instanceof File);
+    const metadataRaw = formData.get("metadata");
+
+    if (!image || audioFiles.length === 0) {
+      return NextResponse.json(
+        { error: "Provide multipart fields: image (file), audio (one or more files)" },
+        { status: 400 },
+      );
+    }
+
+    const limits = getPlanLimits(user.plan);
+    if (audioFiles.length > limits.maxBatchSize) {
+      return NextResponse.json(
+        { error: `Batch limit exceeded. Your plan allows up to ${limits.maxBatchSize} files per batch.` },
+        { status: 400 },
+      );
+    }
+
+    const quotaCheck = await checkQuota(user.id, audioFiles.length);
+    if (!quotaCheck.ok) {
+      return NextResponse.json({ error: quotaCheck.error }, { status: 403 });
+    }
+
+    let itemMeta: BatchItemInput[] = [];
+    let defaults: Partial<ItemMetadata> = {};
+    let createPlaylist: CreatePlaylistRequest | null = null;
+
+    if (metadataRaw) {
+      try {
+        const parsed = JSON.parse(String(metadataRaw)) as {
+          items?: BatchItemInput[];
+          defaults?: Partial<ItemMetadata>;
+          createPlaylist?: unknown;
+        };
+        itemMeta = parsed.items ?? [];
+        defaults = parsed.defaults ?? {};
+        createPlaylist = parseCreatePlaylistInput(parsed.createPlaylist);
+        if (parsed.createPlaylist && !createPlaylist) {
+          return NextResponse.json(
+            {
+              error:
+                "createPlaylist requires a title. Optional: description, privacy (public|unlisted|private)",
+            },
+            { status: 400 },
+          );
+        }
+      } catch {
+        return NextResponse.json({ error: "metadata must be valid JSON" }, { status: 400 });
+      }
+    }
+
+    const sessionKey = Date.now().toString();
+    const imageUpload = await saveUploadedFile(user.id, image, "image", user.plan, { sessionKey });
+
+    const uploads = await mapWithConcurrency(audioFiles, 4, (audio) =>
+      saveUploadedFile(user.id, audio, "audio", user.plan, { sessionKey }),
+    );
+
+    const builtItems: CreateJobPayload["items"] = uploads.map((upload, i) => {
+      const audio = audioFiles[i];
+      const metaInput = itemMeta[i] ?? itemMeta.find((m) => m.filename === audio.name) ?? {};
+      const base = defaultMetadata(
+        metaInput.title?.trim() || filenameWithoutExtension(audio.name),
+      );
+      const metadata: ItemMetadata = {
+        ...base,
+        ...defaults,
+        ...metaInput,
+        title: (metaInput.title ?? defaults.title ?? base.title).trim(),
+        privacy: (metaInput.privacy ?? defaults.privacy ?? base.privacy) as Privacy,
+      };
+
+      return {
+        audioPath: upload.path,
+        audioFilename: upload.filename,
+        metadata,
+      };
+    });
+
+    const { items, playlist } = await applyCreatePlaylistToItems(user, builtItems, createPlaylist);
+
+    const job = await createVideoJob(user, {
+      imagePath: imageUpload.path,
+      items,
+    });
+
+    return NextResponse.json({
+      jobId: job.id,
+      itemCount: job.items.length,
+      status: job.status,
+      playlist: playlist
+        ? { id: playlist.id, title: playlist.title, privacy: playlist.privacy }
+        : null,
+    });
+  } catch (err) {
+    console.error("Batch upload failed:", err);
+    const message = err instanceof Error ? err.message : "Batch upload failed";
+    const status = message.includes("Quota exceeded") || message.includes("Batch limit exceeded")
+      ? 403
+      : 500;
+    return NextResponse.json({ error: message }, { status });
+  }
+}

app/api/v1/jobs/route.ts

@@ -0,0 +1,88 @@
+import { NextRequest, NextResponse } from "next/server";
+import { requirePaidApiUser } from "@/lib/api-auth";
+import { createVideoJob } from "@/lib/jobs/create-job";
+import {
+  applyCreatePlaylistToItems,
+  parseCreatePlaylistInput,
+} from "@/lib/jobs/resolve-playlist";
+import { prisma } from "@/lib/db";
+import type { CreateJobPayload } from "@/lib/types";
+
+export async function POST(req: NextRequest) {
+  const { error, user } = await requirePaidApiUser(req);
+  if (error || !user) return error!;
+
+  const body = (await req.json()) as CreateJobPayload & { createPlaylist?: unknown };
+
+  try {
+    const createPlaylist = parseCreatePlaylistInput(body.createPlaylist);
+    if (body.createPlaylist && !createPlaylist) {
+      return NextResponse.json(
+        {
+          error:
+            "createPlaylist requires a title. Optional: description, privacy (public|unlisted|private)",
+        },
+        { status: 400 },
+      );
+    }
+
+    const { items, playlist } = await applyCreatePlaylistToItems(
+      user,
+      body.items,
+      createPlaylist,
+    );
+
+    const job = await createVideoJob(user, {
+      imagePath: body.imagePath,
+      items,
+    });
+
+    return NextResponse.json({
+      jobId: job.id,
+      itemCount: job.items.length,
+      status: job.status,
+      playlist: playlist
+        ? { id: playlist.id, title: playlist.title, privacy: playlist.privacy }
+        : null,
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to create job";
+    const status = message.includes("Quota exceeded") ? 403 : 400;
+    return NextResponse.json({ error: message }, { status });
+  }
+}
+
+export async function GET(req: NextRequest) {
+  const { error, user } = await requirePaidApiUser(req);
+  if (error || !user) return error!;
+
+  const limit = Math.min(Number(req.nextUrl.searchParams.get("limit")) || 20, 100);
+
+  const jobs = await prisma.job.findMany({
+    where: { userId: user.id },
+    orderBy: { createdAt: "desc" },
+    take: limit,
+    include: {
+      items: {
+        select: {
+          id: true,
+          audioFilename: true,
+          title: true,
+          status: true,
+          youtubeVideoId: true,
+          error: true,
+        },
+      },
+    },
+  });
+
+  return NextResponse.json({
+    jobs: jobs.map((job) => ({
+      id: job.id,
+      status: job.status,
+      createdAt: job.createdAt.toISOString(),
+      completedAt: job.completedAt?.toISOString() ?? null,
+      items: job.items,
+    })),
+  });
+}

app/api/v1/playlists/route.ts

@@ -0,0 +1,44 @@
+import { NextRequest, NextResponse } from "next/server";
+import { requirePaidApiUser } from "@/lib/api-auth";
+import { parseCreatePlaylistInput } from "@/lib/jobs/resolve-playlist";
+import { createYouTubePlaylist, listYouTubePlaylists } from "@/lib/youtube/upload";
+
+export async function GET(req: NextRequest) {
+  const { error, user } = await requirePaidApiUser(req);
+  if (error || !user) return error!;
+
+  try {
+    const playlists = await listYouTubePlaylists(user.id);
+    return NextResponse.json({ playlists });
+  } catch (err) {
+    console.error("List playlists failed:", err);
+    const message = err instanceof Error ? err.message : "Failed to list playlists";
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}
+
+export async function POST(req: NextRequest) {
+  const { error, user } = await requirePaidApiUser(req);
+  if (error || !user) return error!;
+
+  try {
+    const body = await req.json();
+    const input = parseCreatePlaylistInput(body);
+    if (!input) {
+      return NextResponse.json(
+        {
+          error:
+            "Provide JSON body: { title, description?, privacy? } where privacy is public|unlisted|private",
+        },
+        { status: 400 },
+      );
+    }
+
+    const playlist = await createYouTubePlaylist(user.id, input);
+    return NextResponse.json({ playlist });
+  } catch (err) {
+    console.error("Create playlist failed:", err);
+    const message = err instanceof Error ? err.message : "Failed to create playlist";
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}

app/api/v1/route.ts

@@ -0,0 +1,61 @@
+import { NextResponse } from "next/server";
+
+export async function GET() {
+  return NextResponse.json({
+    name: "Songs2YT API",
+    version: "1.0",
+    authentication: "Authorization: Bearer <api_key>",
+    requirements: ["Pro subscription", "YouTube account connected"],
+    rateLimit: "60 requests per minute per account (plus any approved bonus)",
+    guidance: {
+      recommended:
+        "For most jobs (especially 5+ audio files): POST /api/v1/upload per file, then POST /api/v1/jobs with the returned paths",
+      batch:
+        "POST /api/v1/jobs/batch is for small packs only. Large multipart bodies may fail with 'failed to parse body as FormData'",
+    },
+    endpoints: [
+      {
+        method: "POST",
+        path: "/api/v1/upload",
+        description: "Upload a single image or audio file (use for two-step flow)",
+        body: "multipart/form-data: file, type (image|audio)",
+      },
+      {
+        method: "POST",
+        path: "/api/v1/jobs",
+        description: "Create a video job from uploaded file paths (recommended for large batches)",
+        body: "application/json: { imagePath, items[] }",
+      },
+      {
+        method: "POST",
+        path: "/api/v1/jobs/batch",
+        description:
+          "One-shot batch for small packs only; large uploads may fail FormData parsing; prefer upload + jobs",
+        body: "multipart/form-data: image, audio[] (repeatable), metadata? (JSON string)",
+      },
+      {
+        method: "GET",
+        path: "/api/v1/playlists",
+        description: "List YouTube playlists for the authenticated Pro account",
+      },
+      {
+        method: "POST",
+        path: "/api/v1/playlists",
+        description: "Create a YouTube playlist",
+        body: "application/json: { title, description?, privacy? (public|unlisted|private) }",
+      },
+      {
+        method: "GET",
+        path: "/api/v1/jobs",
+        description: "List recent jobs",
+        query: "limit (default 20, max 100)",
+      },
+      {
+        method: "GET",
+        path: "/api/v1/jobs/:id",
+        description: "Get job status and item details",
+      },
+    ],
+    docs: "/dashboard/api-docs",
+  });
+}

app/api/v1/upload/route.ts

@@ -0,0 +1,29 @@
+import { NextRequest, NextResponse } from "next/server";
+import { requirePaidApiUser } from "@/lib/api-auth";
+import { saveUploadedFile } from "@/lib/jobs/create-job";
+
+export const maxDuration = 120;
+
+export async function POST(req: NextRequest) {
+  const { error, user } = await requirePaidApiUser(req);
+  if (error || !user) return error!;
+
+  const formData = await req.formData();
+  const file = formData.get("file") as File | null;
+  const type = formData.get("type") as string | null;
+
+  if (!file || !type || (type !== "image" && type !== "audio")) {
+    return NextResponse.json(
+      { error: "Provide multipart fields: file, type (image|audio)" },
+      { status: 400 },
+    );
+  }
+
+  try {
+    const result = await saveUploadedFile(user.id, file, type, user.plan);
+    return NextResponse.json(result);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Upload failed";
+    return NextResponse.json({ error: message }, { status: 400 });
+  }
+}

app/api/youtube/playlists/route.ts

@@ -0,0 +1,63 @@
+import { NextRequest, NextResponse } from "next/server";
+import { hasProFeatures } from "@/lib/edition";
+import { getSessionUser } from "@/lib/session";
+import { parseCreatePlaylistInput } from "@/lib/jobs/resolve-playlist";
+import { createYouTubePlaylist, listYouTubePlaylists } from "@/lib/youtube/upload";
+
+async function requirePremiumYouTubeUser() {
+  const user = await getSessionUser();
+  if (!user) {
+    return { error: NextResponse.json({ error: "Unauthorized" }, { status: 401 }), user: null };
+  }
+  if (!hasProFeatures(user.plan)) {
+    return {
+      error: NextResponse.json(
+        { error: "Playlist features are available on the Pro plan only" },
+        { status: 403 },
+      ),
+      user: null,
+    };
+  }
+  if (!user.youtubeConnection) {
+    return {
+      error: NextResponse.json({ error: "YouTube account not connected" }, { status: 403 }),
+      user: null,
+    };
+  }
+  return { error: null, user };
+}
+
+export async function GET() {
+  const { error, user } = await requirePremiumYouTubeUser();
+  if (error || !user) return error!;
+
+  try {
+    const playlists = await listYouTubePlaylists(user.id);
+    return NextResponse.json({ playlists });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to list playlists";
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}
+
+export async function POST(req: NextRequest) {
+  const { error, user } = await requirePremiumYouTubeUser();
+  if (error || !user) return error!;
+
+  try {
+    const body = await req.json();
+    const input = parseCreatePlaylistInput(body);
+    if (!input) {
+      return NextResponse.json(
+        { error: "Provide title, and optionally description and privacy (public|unlisted|private)" },
+        { status: 400 },
+      );
+    }
+
+    const playlist = await createYouTubePlaylist(user.id, input);
+    return NextResponse.json({ playlist });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to create playlist";
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}

app/dashboard/api-docs/page.tsx

@@ -0,0 +1,219 @@
+import Link from "next/link";
+import { redirect } from "next/navigation";
+import { getServerSession } from "next-auth";
+import { authOptions } from "@/lib/auth";
+import { hasProFeatures } from "@/lib/edition";
+import { prisma } from "@/lib/db";
+import { DashboardShell } from "@/components/DashboardShell";
+import { UpgradeProLink } from "@/components/UpgradeProLink";
+
+function CodeBlock({ children }: { children: string }) {
+  return (
+    <pre className="overflow-x-auto rounded-lg border border-gray-800 bg-black/40 p-4 text-xs leading-relaxed text-gray-300">
+      <code>{children}</code>
+    </pre>
+  );
+}
+
+export default async function ApiDocsPage() {
+  const session = await getServerSession(authOptions);
+  if (!session?.user?.email) redirect("/");
+
+  const user = await prisma.user.findUnique({
+    where: { email: session.user.email },
+    include: { youtubeConnection: true },
+  });
+  if (!user) redirect("/");
+
+  const isPro = hasProFeatures(user.plan);
+
+  return (
+    <DashboardShell channelTitle={user.youtubeConnection?.channelTitle}>
+      <div className="mx-auto max-w-3xl space-y-8">
+        <div>
+          <Link
+            href="/dashboard/settings"
+            className="text-sm text-gray-400 transition-colors hover:text-white"
+          >
+            ← Back to settings
+          </Link>
+          <h1 className="mt-4 text-2xl font-bold text-white">REST API</h1>
+          <p className="mt-2 text-sm text-gray-400">
+            Programmatic uploads and batch jobs for Pro subscribers. Generate your API key in{" "}
+            <Link href="/dashboard/settings" className="text-accent hover:underline">
+              Settings
+            </Link>
+            .
+          </p>
+          {!isPro && (
+            <p className="mt-3 rounded border border-accent/30 bg-accent/10 px-4 py-3 text-sm text-accent">
+              API access requires Pro. <UpgradeProLink />
+            </p>
+          )}
+        </div>
+
+        <section className="space-y-3">
+          <h2 className="text-lg font-semibold text-white">Authentication</h2>
+          <p className="text-sm text-gray-400">
+            Send your API key on every request. Keys start with <code className="text-gray-300">s2yt_live_</code>.
+          </p>
+          <CodeBlock>{`Authorization: Bearer s2yt_live_your_key_here`}</CodeBlock>
+        </section>
+
+        <section className="space-y-3">
+          <h2 className="text-lg font-semibold text-white">Rate limits</h2>
+          <p className="text-sm text-gray-400">
+            Default is 60 requests per minute per account. Approved rate-limit extensions increase
+            that ceiling. Check live usage and request an extension in{" "}
+            <Link href="/dashboard/settings" className="text-accent hover:underline">
+              Settings → API access
+            </Link>
+            . Video quota limits from your Pro plan still apply to job creation.
+          </p>
+        </section>
+
+        <section className="space-y-3">
+          <h2 className="text-lg font-semibold text-white">Choosing a flow</h2>
+          <div className="rounded border border-gray-800 bg-surface p-4 text-sm text-gray-400 space-y-3">
+            <p>
+              <span className="font-medium text-white">Recommended for most jobs (especially 5+ audio files):</span>{" "}
+              two-step: upload each file with <code className="text-gray-300">POST /api/v1/upload</code>, then
+              create the job with <code className="text-gray-300">POST /api/v1/jobs</code> (JSON).
+            </p>
+            <p>
+              <span className="font-medium text-white">One-shot batch</span>{" "}
+              (<code className="text-gray-300">POST /api/v1/jobs/batch</code>) is for small packs only, typically
+              1 cover + up to a few audio files. Large multipart bodies often fail with{" "}
+              <code className="text-gray-300">failed to parse body as FormData</code>. Prefer two-step for albums
+              or long tracklists.
+            </p>
+            <ul className="list-disc space-y-1 pl-5">
+              <li>Do not set <code className="text-gray-300">Content-Type</code> manually for multipart; the client must include the boundary.</li>
+              <li>For Postman: Body → form-data, each audio row key must be exactly <code className="text-gray-300">audio</code> (type File).</li>
+              <li>If a file field shows a warning triangle, re-select the file from disk.</li>
+            </ul>
+          </div>
+        </section>
+
+        <section className="space-y-3">
+          <h2 className="text-lg font-semibold text-white">Discovery</h2>
+          <CodeBlock>{`GET /api/v1`}</CodeBlock>
+          <p className="text-sm text-gray-400">Returns endpoint list and requirements (no auth).</p>
+        </section>
+
+        <section className="space-y-3">
+          <h2 className="text-lg font-semibold text-white">1. Upload a file (two-step)</h2>
+          <CodeBlock>{`curl -X POST "$BASE_URL/api/v1/upload" \\
+  -H "Authorization: Bearer $API_KEY" \\
+  -F "file=@cover.jpg" \\
+  -F "type=image"`}</CodeBlock>
+          <CodeBlock>{`curl -X POST "$BASE_URL/api/v1/upload" \\
+  -H "Authorization: Bearer $API_KEY" \\
+  -F "file=@track1.mp3" \\
+  -F "type=audio"`}</CodeBlock>
+          <p className="text-sm text-gray-400">
+            Response includes <code className="text-gray-300">path</code>,{" "}
+            <code className="text-gray-300">filename</code>, and{" "}
+            <code className="text-gray-300">size</code>. Upload the image once, then each audio file. Keep the{" "}
+            <code className="text-gray-300">path</code> values for the next step.
+          </p>
+        </section>
+
+        <section className="space-y-3">
+          <h2 className="text-lg font-semibold text-white">2. Create job from paths (recommended)</h2>
+          <p className="text-sm text-gray-400">
+            Use the exact <code className="text-gray-300">path</code> strings returned by upload. Add one{" "}
+            <code className="text-gray-300">items[]</code> entry per track.
+          </p>
+          <CodeBlock>{`curl -X POST "$BASE_URL/api/v1/jobs" \\
+  -H "Authorization: Bearer $API_KEY" \\
+  -H "Content-Type: application/json" \\
+  -d '{
+    "imagePath": "/uploads/.../cover.jpg",
+    "items": [{
+      "audioPath": "/uploads/.../track.mp3",
+      "audioFilename": "track.mp3",
+      "metadata": {
+        "title": "My Track",
+        "description": "",
+        "tags": "electronic",
+        "privacy": "PUBLIC",
+        "categoryId": "10",
+        "resolution": "1920x1080",
+        "notifySubscribers": true,
+        "madeForKids": false,
+        "embeddable": true,
+        "creativeCommons": false,
+        "includeWatermark": false,
+        "playlistId": null
+      }
+    }]
+  }'`}</CodeBlock>
+        </section>
+
+        <section className="space-y-3">
+          <h2 className="text-lg font-semibold text-white">YouTube playlists (Pro)</h2>
+          <p className="text-sm text-gray-400">
+            List existing playlists, create a new one, or create one inline when starting a job.
+            Pass <code className="text-gray-300">playlistId</code> in item metadata / batch{" "}
+            <code className="text-gray-300">defaults</code>, or use{" "}
+            <code className="text-gray-300">createPlaylist</code> to make a playlist and attach all
+            videos to it. Privacy may be <code className="text-gray-300">public</code>,{" "}
+            <code className="text-gray-300">unlisted</code>, or{" "}
+            <code className="text-gray-300">private</code>. If playlist permission was just added,
+            sign out and sign in again for <code className="text-gray-300">youtube.force-ssl</code>.
+          </p>
+          <CodeBlock>{`# List playlists
+curl "$BASE_URL/api/v1/playlists" \\
+  -H "Authorization: Bearer $API_KEY"`}</CodeBlock>
+          <CodeBlock>{`# Create a playlist
+curl -X POST "$BASE_URL/api/v1/playlists" \\
+  -H "Authorization: Bearer $API_KEY" \\
+  -H "Content-Type: application/json" \\
+  -d '{"title":"My Album","description":"From Songs2YT","privacy":"unlisted"}'`}</CodeBlock>
+          <CodeBlock>{`# Use an existing playlist ID in metadata / defaults:
+{ "playlistId": "PLxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" }
+
+# Or create one inline with a job / batch request:
+{
+  "createPlaylist": {
+    "title": "My Album",
+    "description": "Uploaded via Songs2YT",
+    "privacy": "private"
+  },
+  "defaults": { "privacy": "PUBLIC" },
+  "items": [{ "title": "Track One" }]
+}`}</CodeBlock>
+        </section>
+
+        <section className="space-y-3">
+          <h2 className="text-lg font-semibold text-white">One-shot batch (small packs only)</h2>
+          <p className="text-sm text-gray-400">
+            Upload one cover image and a few audio files in a single multipart request. Not recommended for
+            large batches: use two-step instead if you see FormData parse errors.
+          </p>
+          <CodeBlock>{`curl -X POST "$BASE_URL/api/v1/jobs/batch" \\
+  -H "Authorization: Bearer $API_KEY" \\
+  -F "image=@cover.jpg" \\
+  -F "audio=@track1.mp3" \\
+  -F "audio=@track2.mp3" \\
+  -F 'metadata={"createPlaylist":{"title":"My Album","privacy":"unlisted"},"defaults":{"privacy":"PUBLIC"},"items":[{"title":"Track One"},{"title":"Track Two"}]}'`}</CodeBlock>
+          <p className="text-sm text-gray-400">
+            Optional <code className="text-gray-300">metadata</code> JSON supports{" "}
+            <code className="text-gray-300">defaults</code> applied to every item and per-item overrides in{" "}
+            <code className="text-gray-300">items</code>. Item order should match the order of{" "}
+            <code className="text-gray-300">audio</code> files.
+          </p>
+        </section>
+
+        <section className="space-y-3">
+          <h2 className="text-lg font-semibold text-white">Poll job status</h2>
+          <CodeBlock>{`curl "$BASE_URL/api/v1/jobs/JOB_ID" \\
+  -H "Authorization: Bearer $API_KEY"`}</CodeBlock>
+          <CodeBlock>{`curl "$BASE_URL/api/v1/jobs?limit=10" \\
+  -H "Authorization: Bearer $API_KEY"`}</CodeBlock>
+        </section>
+      </div>
+    </DashboardShell>
+  );
+}

app/dashboard/history/page.tsx

@@ -0,0 +1,19 @@
+import { redirect } from "next/navigation";
+import { getServerSession } from "next-auth";
+import { authOptions } from "@/lib/auth";
+import { DashboardShell } from "@/components/DashboardShell";
+import { JobHistory } from "@/components/JobHistory";
+
+export default async function HistoryPage() {
+  const session = await getServerSession(authOptions);
+  if (!session) redirect("/");
+
+  return (
+    <DashboardShell channelTitle={session.user.channelTitle}>
+      <div className="mx-auto max-w-4xl px-6 py-8">
+        <h1 className="mb-6 text-2xl font-bold text-white">History</h1>
+        <JobHistory />
+      </div>
+    </DashboardShell>
+  );
+}

app/dashboard/page.tsx

@@ -0,0 +1,21 @@
+import { redirect } from "next/navigation";
+import { getServerSession } from "next-auth";
+import { authOptions } from "@/lib/auth";
+import { DashboardShell } from "@/components/DashboardShell";
+import { RecentYouTubeLimitAlert } from "@/components/RecentYouTubeLimitAlert";
+import { UploadForm } from "@/components/UploadForm";
+
+export default async function DashboardPage() {
+  const session = await getServerSession(authOptions);
+  if (!session) redirect("/");
+
+  return (
+    <DashboardShell channelTitle={session.user.channelTitle}>
+      <div className="mx-auto max-w-4xl px-6 py-8">
+        <h1 className="mb-6 text-2xl font-bold text-white">Create Videos</h1>
+        <RecentYouTubeLimitAlert />
+        <UploadForm />
+      </div>
+    </DashboardShell>
+  );
+}

app/dashboard/settings/page.tsx

@@ -0,0 +1,224 @@
+import Link from "next/link";
+import { redirect } from "next/navigation";
+import { getServerSession } from "next-auth";
+import { authOptions } from "@/lib/auth";
+import { prisma } from "@/lib/db";
+import { AccountPrivacyActions } from "@/components/AccountPrivacyActions";
+import { PlanBillingActions } from "@/components/PlanBillingActions";
+import { DashboardShell } from "@/components/DashboardShell";
+import { UpgradeProLink } from "@/components/UpgradeProLink";
+import { getUserApiKeyStatus } from "@/lib/api-keys";
+import { getApiRateLimitStatus } from "@/lib/api-rate-limit";
+import { ApiKeySettings } from "@/components/ApiKeySettings";
+import { hasProFeatures, isSelfHostedEdition } from "@/lib/edition";
+import { EXTENSION_KIND, getQuotaExtensionUsage } from "@/lib/quota-extensions";
+import { getQuotaInfo } from "@/lib/quota";
+
+const PLAN_LABELS = {
+  FREE: "Bedroom Producer",
+  PREMIUM: "Pro",
+} as const;
+
+function InfoRow({ label, value }: { label: string; value: string }) {
+  return (
+    <div className="flex justify-between gap-4">
+      <dt className="text-gray-400">{label}</dt>
+      <dd className="text-right text-white">{value}</dd>
+    </div>
+  );
+}
+
+export default async function SettingsPage() {
+  const session = await getServerSession(authOptions);
+  if (!session?.user?.email) redirect("/");
+
+  const user = await prisma.user.findUnique({
+    where: { email: session.user.email },
+    include: { youtubeConnection: true },
+  });
+  if (!user) redirect("/");
+
+  const quota = await getQuotaInfo(user.id);
+  const selfHosted = isSelfHostedEdition();
+  const proFeatures = hasProFeatures(user.plan);
+  const extensionUsage =
+    !selfHosted && user.plan === "PREMIUM" ? await getQuotaExtensionUsage(user.id) : null;
+  const apiRateExtensionUsage = proFeatures
+    ? await getQuotaExtensionUsage(user.id, EXTENSION_KIND.API_RATE_LIMIT)
+    : null;
+  const apiKeyStatus = proFeatures ? await getUserApiKeyStatus(user.id) : null;
+  const apiRateLimit = proFeatures ? await getApiRateLimitStatus(user.id) : null;
+  const planLabel = selfHosted ? "Self-hosted" : PLAN_LABELS[user.plan];
+  const youtube = user.youtubeConnection;
+  const channelUrl = youtube ? `https://www.youtube.com/channel/${youtube.channelId}` : null;
+
+  return (
+    <DashboardShell channelTitle={youtube?.channelTitle}>
+      <div className="mx-auto max-w-4xl px-6 py-8">
+        <h1 className="mb-6 text-2xl font-bold text-white">Settings</h1>
+
+        <div className="space-y-6">
+          <section className="rounded-lg border border-gray-700 bg-surface-light p-6">
+            <h2 className="mb-4 text-lg font-semibold text-white">Account information</h2>
+            <dl className="space-y-3 text-sm">
+              <InfoRow label="Name" value={user.name || "Not set"} />
+              <InfoRow label="Email" value={user.email} />
+            </dl>
+
+            <div className="mt-6 border-t border-gray-800 pt-6">
+              <h3 className="mb-4 text-sm font-semibold uppercase tracking-wider text-gray-500">
+                YouTube
+              </h3>
+              {youtube ? (
+                <dl className="space-y-3 text-sm">
+                  <InfoRow label="Channel name" value={youtube.channelTitle} />
+                  <InfoRow label="Channel ID" value={youtube.channelId} />
+                </dl>
+              ) : (
+                <p className="text-sm text-red-400">YouTube account not connected.</p>
+              )}
+
+              {channelUrl && (
+                <a
+                  href={channelUrl}
+                  target="_blank"
+                  rel="noopener noreferrer"
+                  className="mt-4 inline-flex rounded bg-accent px-4 py-2 text-sm font-medium text-white transition-colors hover:bg-accent-hover"
+                >
+                  Go to your channel
+                </a>
+              )}
+
+              <p className="mt-4 text-sm text-gray-400">
+                To refresh your YouTube permissions,{" "}
+                <Link href="/" className="text-accent hover:underline">
+                  sign out and sign in again
+                </Link>
+                .
+              </p>
+            </div>
+          </section>
+
+          <section className="rounded-lg border border-gray-700 bg-surface-light p-6">
+            <h2 className="mb-4 text-lg font-semibold text-white">
+              {selfHosted ? "Usage" : "Plan & billing"}
+            </h2>
+
+            <div className="mb-6 rounded border border-gray-800 bg-surface p-4">
+              <div className="flex flex-wrap items-end justify-between gap-2">
+                <div>
+                  <p className="text-xs font-semibold uppercase tracking-wider text-gray-500">
+                    Videos processed
+                  </p>
+                  <p className="mt-1 text-2xl font-semibold text-white">
+                    {selfHosted ? (
+                      quota.used
+                    ) : (
+                      <>
+                        {quota.remaining}
+                        <span className="text-base font-normal text-gray-400">
+                          {" "}
+                          of {quota.limit} videos
+                        </span>
+                      </>
+                    )}
+                  </p>
+                </div>
+                {!selfHosted && (
+                  <p className="text-sm text-gray-400">
+                    {quota.used} used
+                    {quota.bonusQuota > 0 ? ` · +${quota.bonusQuota} bonus` : ""}
+                  </p>
+                )}
+              </div>
+              {!selfHosted && (
+                <>
+                  <div className="mt-3 h-2 overflow-hidden rounded bg-gray-800">
+                    <div
+                      className={`h-full rounded ${
+                        quota.remaining <= 0
+                          ? "bg-red-500"
+                          : quota.remaining / Math.max(1, quota.limit) <= 0.2
+                            ? "bg-amber-500"
+                            : "bg-accent"
+                      }`}
+                      style={{
+                        width: `${Math.min(100, Math.round((quota.used / Math.max(1, quota.limit)) * 100))}%`,
+                      }}
+                    />
+                  </div>
+                  <p className="mt-2 text-xs text-gray-500">
+                    {user.plan === "PREMIUM"
+                      ? `Monthly quota resets on ${quota.resetsIn}`
+                      : `Quota resets in ${quota.resetsIn}`}
+                  </p>
+                </>
+              )}
+              {selfHosted && (
+                <p className="mt-2 text-xs text-gray-500">
+                  Self-hosted edition: no video or API quotas.
+                </p>
+              )}
+            </div>
+
+            <dl className="space-y-3 text-sm">
+              <InfoRow label="Current plan" value={planLabel} />
+              {!selfHosted && user.plan === "PREMIUM" && user.subscribedAt && (
+                <InfoRow
+                  label="Subscribed since"
+                  value={user.subscribedAt.toLocaleDateString(undefined, {
+                    year: "numeric",
+                    month: "long",
+                    day: "numeric",
+                  })}
+                />
+              )}
+              {!selfHosted && user.plan === "PREMIUM" && (
+                <InfoRow
+                  label="Payment method"
+                  value={user.cardLast4 ? `•••• ${user.cardLast4}` : "No card on file"}
+                />
+              )}
+              {extensionUsage && (
+                <InfoRow
+                  label="Extension requests (this year)"
+                  value={`${extensionUsage.used} / ${extensionUsage.limit}`}
+                />
+              )}
+              <InfoRow label="Max batch size" value={`${quota.maxBatchSize} videos`} />
+              <InfoRow label="Max resolution" value={`${quota.maxResolutionHeight}p`} />
+            </dl>
+
+            {!selfHosted && user.plan === "FREE" && (
+              <p className="mt-4 text-sm text-gray-400">
+                <UpgradeProLink /> for more videos, 1080p, and lossless audio.
+              </p>
+            )}
+            {!selfHosted && user.plan === "PREMIUM" && extensionUsage && (
+              <PlanBillingActions initialUsage={extensionUsage} />
+            )}
+          </section>
+
+          {proFeatures && apiKeyStatus && apiRateLimit && apiRateExtensionUsage && (
+            <section className="rounded-lg border border-gray-700 bg-surface-light p-6">
+              <h2 className="mb-4 text-lg font-semibold text-white">API access</h2>
+              <ApiKeySettings
+                initialStatus={apiKeyStatus}
+                initialRateLimit={apiRateLimit}
+                initialExtensionUsage={apiRateExtensionUsage}
+              />
+            </section>
+          )}
+
+          <section className="rounded-lg border border-gray-700 bg-surface-light p-6">
+            <h2 className="mb-2 text-lg font-semibold text-white">Account deletion &amp; data</h2>
+            <p className="mb-4 text-sm text-gray-400">
+              Request a copy of your data or permanently delete your account and associated uploads.
+            </p>
+            <AccountPrivacyActions email={user.email} />
+          </section>
+        </div>
+      </div>
+    </DashboardShell>
+  );
+}

app/globals.css

@@ -0,0 +1,248 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+@layer base {
+  html {
+    scroll-behavior: smooth;
+  }
+
+  body {
+    @apply bg-surface-dark text-gray-100 antialiased;
+  }
+}
+
+@layer components {
+  .input-field {
+    @apply w-full rounded border border-gray-600 bg-surface-light px-3 py-2 text-sm text-white placeholder-gray-500 focus:border-accent focus:outline-none;
+  }
+
+  .mockup-upload-box {
+    animation: mockup-border-pulse 3s ease-in-out infinite;
+  }
+
+  .mockup-upload-box-image {
+    animation: mockup-border-pulse 3s ease-in-out infinite,
+      mockup-float 4s ease-in-out infinite;
+  }
+
+  .mockup-upload-box-audio {
+    animation: mockup-border-pulse 3s ease-in-out infinite 0.5s,
+      mockup-float 4s ease-in-out infinite 0.5s;
+  }
+
+  .mockup-icon-image {
+    animation: mockup-icon-glow 3s ease-in-out infinite;
+  }
+
+  .mockup-icon-audio {
+    animation: mockup-icon-glow 3s ease-in-out infinite 0.5s;
+  }
+
+  .mockup-progress-shimmer {
+    animation: mockup-shimmer 2s ease-in-out infinite;
+  }
+
+  .mockup-dot-1 {
+    animation: processing-dot 1.4s ease-in-out infinite;
+  }
+
+  .mockup-dot-2 {
+    animation: processing-dot 1.4s ease-in-out infinite 0.2s;
+  }
+
+  .mockup-dot-3 {
+    animation: processing-dot 1.4s ease-in-out infinite 0.4s;
+  }
+
+  .benefits-flow-line {
+    animation: benefits-flow-pulse 2s ease-in-out infinite;
+  }
+
+  .benefits-process-icon {
+    animation: benefits-process-pulse 2.5s ease-in-out infinite;
+  }
+
+  .benefits-flow-path {
+    stroke-dasharray: 6 8;
+    animation: benefits-flow-dash 2s linear infinite;
+  }
+
+  .mobile-sidebar-panel-open {
+    animation: mobile-sidebar-open 0.42s cubic-bezier(0.22, 1, 0.36, 1) forwards;
+  }
+
+  .mobile-sidebar-panel-close {
+    animation: mobile-sidebar-close 0.3s cubic-bezier(0.4, 0, 1, 1) forwards;
+  }
+
+  .mobile-sidebar-close-btn-open {
+    animation: mobile-sidebar-close-btn-in 0.35s cubic-bezier(0.22, 1, 0.36, 1) forwards;
+  }
+
+  .mobile-sidebar-close-btn-close {
+    animation: mobile-sidebar-close-btn-out 0.2s ease-in forwards;
+  }
+
+  .mobile-sidebar-link {
+    @apply relative block overflow-hidden rounded-lg px-4 py-3 text-base font-medium text-gray-300 transition-all duration-300 ease-out;
+  }
+
+  .mobile-sidebar-link::before {
+    content: "";
+    @apply absolute bottom-2 left-0 top-2 w-1 origin-left scale-y-0 rounded-r bg-accent transition-transform duration-300 ease-out;
+  }
+
+  .mobile-sidebar-link:hover {
+    @apply translate-x-1 bg-surface-light text-white shadow-[inset_0_0_0_1px_rgba(74,158,255,0.12)];
+  }
+
+  .mobile-sidebar-link:hover::before {
+    @apply scale-y-100;
+  }
+
+  .mobile-sidebar-link-active {
+    @apply bg-surface-light text-white shadow-[inset_0_0_0_1px_rgba(74,158,255,0.2)];
+  }
+
+  .mobile-sidebar-link-active::before {
+    @apply scale-y-100;
+  }
+
+  .mobile-sidebar-link-danger:hover {
+    @apply bg-red-500/10 text-red-300 shadow-[inset_0_0_0_1px_rgba(239,68,68,0.2)];
+  }
+
+  .mobile-sidebar-link-danger:hover::before {
+    @apply bg-red-400;
+  }
+}
+
+@keyframes mockup-float {
+  0%,
+  100% {
+    transform: translateY(0);
+  }
+  50% {
+    transform: translateY(-3px);
+  }
+}
+
+@keyframes mockup-border-pulse {
+  0%,
+  100% {
+    border-color: rgb(75 85 99 / 0.5);
+    box-shadow: 0 0 0 0 rgb(255 255 255 / 0);
+  }
+  50% {
+    border-color: rgb(156 163 175 / 0.7);
+    box-shadow: 0 0 12px 0 rgb(255 255 255 / 0.04);
+  }
+}
+
+@keyframes mockup-icon-glow {
+  0%,
+  100% {
+    opacity: 0.5;
+    transform: scale(1);
+  }
+  50% {
+    opacity: 0.85;
+    transform: scale(1.05);
+  }
+}
+
+@keyframes mockup-shimmer {
+  0% {
+    left: -30%;
+    opacity: 0;
+  }
+  30% {
+    opacity: 0.6;
+  }
+  100% {
+    left: 100%;
+    opacity: 0;
+  }
+}
+
+@keyframes processing-dot {
+  0%,
+  20% {
+    opacity: 0;
+  }
+  40%,
+  100% {
+    opacity: 1;
+  }
+}
+
+@keyframes benefits-flow-pulse {
+  0%,
+  100% {
+    opacity: 0.4;
+  }
+  50% {
+    opacity: 1;
+  }
+}
+
+@keyframes benefits-process-pulse {
+  0%,
+  100% {
+    box-shadow: 0 0 20px rgba(239, 68, 68, 0.2);
+  }
+  50% {
+    box-shadow: 0 0 28px rgba(239, 68, 68, 0.4);
+  }
+}
+
+@keyframes benefits-flow-dash {
+  to {
+    stroke-dashoffset: -28;
+  }
+}
+
+@keyframes mobile-sidebar-open {
+  from {
+    opacity: 0.85;
+    transform: translateX(100%) scale(0.96);
+  }
+  to {
+    opacity: 1;
+    transform: translateX(0) scale(1);
+  }
+}
+
+@keyframes mobile-sidebar-close {
+  from {
+    opacity: 1;
+    transform: translateX(0) scale(1);
+  }
+  to {
+    opacity: 0.85;
+    transform: translateX(100%) scale(0.96);
+  }
+}
+
+@keyframes mobile-sidebar-close-btn-in {
+  from {
+    opacity: 0;
+    transform: scale(0.6) rotate(-90deg);
+  }
+  to {
+    opacity: 1;
+    transform: scale(1) rotate(0deg);
+  }
+}
+
+@keyframes mobile-sidebar-close-btn-out {
+  from {
+    opacity: 1;
+    transform: scale(1) rotate(0deg);
+  }
+  to {
+    opacity: 0;
+    transform: scale(0.6) rotate(90deg);
+  }
+}

app/jobs/[id]/page.tsx

@@ -0,0 +1,24 @@
+import { redirect } from "next/navigation";
+import { getServerSession } from "next-auth";
+import { authOptions } from "@/lib/auth";
+import { DashboardShell } from "@/components/DashboardShell";
+import { JobProgress } from "@/components/JobProgress";
+
+type Props = {
+  params: Promise<{ id: string }>;
+};
+
+export default async function JobPage({ params }: Props) {
+  const session = await getServerSession(authOptions);
+  if (!session) redirect("/");
+
+  const { id } = await params;
+
+  return (
+    <DashboardShell channelTitle={session.user.channelTitle}>
+      <div className="mx-auto max-w-4xl px-6 py-8">
+        <JobProgress jobId={id} />
+      </div>
+    </DashboardShell>
+  );
+}

app/layout.tsx

@@ -0,0 +1,26 @@
+import type { Metadata } from "next";
+import { Inter } from "next/font/google";
+import "./globals.css";
+import { Providers } from "./providers";
+
+const inter = Inter({ subsets: ["latin"] });
+
+export const metadata: Metadata = {
+  title: "Songs2YT",
+  description:
+    "Songs2YT is an automation tool that converts your audio and image files into high-quality videos and uploads them directly to YouTube.",
+};
+
+export default function RootLayout({
+  children,
+}: Readonly<{
+  children: React.ReactNode;
+}>) {
+  return (
+    <html lang="en">
+      <body className={inter.className}>
+        <Providers>{children}</Providers>
+      </body>
+    </html>
+  );
+}

app/page.tsx

@@ -0,0 +1,92 @@
+import Link from "next/link";
+import { getServerSession } from "next-auth";
+import { authOptions } from "@/lib/auth";
+import { BenefitsSection } from "@/components/BenefitsSection";
+import { DownloadSection } from "@/components/DownloadSection";
+import { LandingNavbar } from "@/components/LandingNavbar";
+import { SignInButton } from "@/components/SignInButton";
+import { PricingSection } from "@/components/PricingSection";
+import { StepsSection } from "@/components/StepsSection";
+import { Footer } from "@/components/Footer";
+import { SupportSection } from "@/components/SupportSection";
+
+export default async function HomePage() {
+  const session = await getServerSession(authOptions);
+
+  return (
+    <main className="min-h-screen">
+      <section className="relative min-h-dvh overflow-hidden">
+        <video
+          autoPlay
+          muted
+          loop
+          playsInline
+          className="absolute inset-0 h-full w-full object-cover"
+          aria-hidden="true"
+        >
+          <source src="/bg-video.mp4" type="video/mp4" />
+        </video>
+        <div className="absolute inset-0 bg-black/55" aria-hidden="true" />
+        <div
+          className="absolute inset-0 bg-gradient-to-b from-black/70 via-black/40 to-black/80"
+          aria-hidden="true"
+        />
+
+        <LandingNavbar />
+
+        {/* Purpose + brand above the fold for Google OAuth verification */}
+        <div className="relative z-10 mx-auto flex min-h-dvh max-w-3xl flex-col justify-center px-6 pb-16 pt-28 text-center">
+          <h1 className="text-5xl font-bold tracking-tight text-white sm:text-6xl lg:text-7xl">
+            Songs2YT
+          </h1>
+          <p className="mx-auto mt-6 max-w-2xl text-base leading-relaxed text-gray-200 sm:text-lg md:text-xl">
+            Songs2YT is an automation tool that converts your audio and image files into
+            high-quality videos and uploads them directly to YouTube.
+          </p>
+
+          <div className="mt-10 flex flex-col items-center gap-3">
+            {session ? (
+              <Link
+                href="/dashboard"
+                className="inline-flex items-center gap-2 rounded bg-accent px-8 py-3.5 font-medium text-white transition-all duration-300 hover:scale-[1.02] hover:bg-accent-hover hover:shadow-lg hover:shadow-accent/20"
+              >
+                Go to Dashboard
+              </Link>
+            ) : (
+              <>
+                <SignInButton large />
+                <p className="max-w-md text-xs leading-relaxed text-gray-400">
+                  By clicking Continue with Google, you accept our{" "}
+                  <Link
+                    href="/terms"
+                    className="text-gray-300 underline-offset-2 transition-colors hover:text-white hover:underline"
+                  >
+                    Terms of Service
+                  </Link>{" "}
+                  and{" "}
+                  <Link
+                    href="/privacy"
+                    className="text-gray-300 underline-offset-2 transition-colors hover:text-white hover:underline"
+                  >
+                    Privacy Policy
+                  </Link>
+                  .
+                </p>
+              </>
+            )}
+          </div>
+        </div>
+      </section>
+
+      <StepsSection />
+      <BenefitsSection />
+
+      <DownloadSection />
+
+      <PricingSection />
+
+      <SupportSection />
+      <Footer />
+    </main>
+  );
+}

app/privacy/page.tsx

@@ -0,0 +1,180 @@
+import type { Metadata } from "next";
+import { LegalPageLayout } from "@/components/LegalPageLayout";
+import { LEGAL_OPERATOR } from "@/lib/legal/constants";
+
+export const metadata: Metadata = {
+  title: "Privacy Policy | Songs2YT",
+  description: "How Songs2YT collects, uses, and protects your personal data.",
+};
+
+export default function PrivacyPage() {
+  return (
+    <LegalPageLayout
+      title="Privacy Policy"
+      description="How we handle your personal data when you use Songs2YT."
+    >
+      <h2>1. Overview</h2>
+      <p>
+        This Privacy Policy explains how {LEGAL_OPERATOR.name} (&quot;we&quot;, &quot;us&quot;)
+        processes personal data when you use our website, hosted cloud service, and related features
+        that convert audio and images into videos for upload to YouTube.
+      </p>
+      <p>
+        We process personal data in accordance with applicable data protection laws, including the
+        General Data Protection Regulation (GDPR) where it applies.
+      </p>
+
+      <h2>2. Data controller</h2>
+      <p>
+        {LEGAL_OPERATOR.legalName}
+        <br />
+        {LEGAL_OPERATOR.address}
+        <br />
+        {LEGAL_OPERATOR.city}
+        <br />
+        Email: <a href={`mailto:${LEGAL_OPERATOR.email}`}>{LEGAL_OPERATOR.email}</a>
+      </p>
+
+      <h2>3. What data we collect</h2>
+      <h3>3.1 Account and authentication data</h3>
+      <p>When you sign in with Google, we receive and store:</p>
+      <ul>
+        <li>Your name, email address, and profile image (from Google)</li>
+        <li>OAuth tokens required to authenticate your session</li>
+        <li>YouTube connection data, including channel ID and title</li>
+        <li>Encrypted YouTube API access and refresh tokens needed to upload videos on your behalf</li>
+      </ul>
+
+      <h3>3.2 Uploaded content</h3>
+      <p>When you use the service, we temporarily process:</p>
+      <ul>
+        <li>Image and audio files you upload</li>
+        <li>Generated video files</li>
+        <li>Per-video metadata you provide (title, description, tags, privacy settings, etc.)</li>
+      </ul>
+
+      <h3>3.3 Usage and technical data</h3>
+      <ul>
+        <li>Plan type, quota usage, and job processing status</li>
+        <li>IP address, browser type, device information, and request logs</li>
+        <li>Error reports and operational diagnostics</li>
+      </ul>
+
+      <h3>3.4 Payment data</h3>
+      <p>
+        If you purchase a paid plan, payment processing is handled by our payment provider. We do
+        not store full payment card details on our servers. We may receive billing status,
+        subscription identifiers, and transaction references.
+      </p>
+
+      <h2>4. Why we process your data</h2>
+      <ul>
+        <li>
+          <strong>Contract performance:</strong> to provide video encoding, metadata handling, and
+          YouTube upload features you request
+        </li>
+        <li>
+          <strong>Legitimate interests:</strong> to secure our service, prevent abuse, improve
+          reliability, and enforce our terms
+        </li>
+        <li>
+          <strong>Legal obligations:</strong> where required by tax, accounting, or regulatory law
+        </li>
+        <li>
+          <strong>Consent:</strong> where you have given explicit consent, such as optional
+          marketing communications if offered
+        </li>
+      </ul>
+
+      <h2>5. Third-party services</h2>
+      <p>We use trusted third parties to operate Songs2YT, including:</p>
+      <ul>
+        <li>
+          <strong>Google / YouTube:</strong> authentication and video uploads via Google OAuth and
+          the YouTube Data API
+        </li>
+        <li>
+          <strong>Hosting and infrastructure providers:</strong> servers, databases, queues, and
+          storage
+        </li>
+        <li>
+          <strong>Payment processors:</strong> for Pro and Enterprise billing when available
+        </li>
+      </ul>
+      <p>
+        These providers process data only as necessary to deliver their services and under
+        appropriate contractual safeguards where required.
+      </p>
+
+      <h2>6. Data retention</h2>
+      <ul>
+        <li>Uploaded source files and generated outputs are retained only as long as needed to complete your jobs</li>
+        <li>Account data is kept while your account remains active</li>
+        <li>Billing records may be retained as required by law</li>
+        <li>Logs are retained for a limited period for security and troubleshooting</li>
+      </ul>
+      <p>You may request deletion of your account data subject to legal retention obligations.</p>
+
+      <h2>7. Self-hosted deployments</h2>
+      <p>
+        If you deploy Songs2YT on your own infrastructure, you are the data controller for data
+        processed on your instance. This Privacy Policy applies to the hosted cloud service
+        operated by us, not to independent self-hosted installations unless we provide managed
+        hosting for you under contract.
+      </p>
+
+      <h2>8. Your rights</h2>
+      <p>Depending on your location, you may have the right to:</p>
+      <ul>
+        <li>Access the personal data we hold about you</li>
+        <li>Request correction or deletion</li>
+        <li>Restrict or object to certain processing</li>
+        <li>Data portability</li>
+        <li>Withdraw consent where processing is consent-based</li>
+        <li>Lodge a complaint with a supervisory authority</li>
+      </ul>
+      <p>
+        To exercise these rights, contact{" "}
+        <a href={`mailto:${LEGAL_OPERATOR.email}`}>{LEGAL_OPERATOR.email}</a>.
+      </p>
+
+      <h2>9. Cookies and local storage</h2>
+      <p>
+        We use essential cookies and similar technologies for authentication, session management,
+        and security. We do not use non-essential tracking cookies unless disclosed separately and
+        enabled with your consent where required.
+      </p>
+
+      <h2>10. Security</h2>
+      <p>
+        We implement appropriate technical and organizational measures to protect your data,
+        including encryption in transit, access controls, and isolated processing environments.
+        No method of transmission or storage is 100% secure.
+      </p>
+
+      <h2>11. International transfers</h2>
+      <p>
+        If data is transferred outside your country, we ensure appropriate safeguards such as
+        standard contractual clauses or equivalent mechanisms where required by law.
+      </p>
+
+      <h2>12. Children</h2>
+      <p>
+        Songs2YT is not directed at children under 16. We do not knowingly collect personal data
+        from children. If you believe a child has provided us data, please contact us.
+      </p>
+
+      <h2>13. Changes to this policy</h2>
+      <p>
+        We may update this Privacy Policy from time to time. Material changes will be posted on
+        this page with an updated effective date.
+      </p>
+
+      <h2>14. Contact</h2>
+      <p>
+        Questions about this Privacy Policy:{" "}
+        <a href={`mailto:${LEGAL_OPERATOR.email}`}>{LEGAL_OPERATOR.email}</a>
+      </p>
+    </LegalPageLayout>
+  );
+}

app/providers.tsx

@@ -0,0 +1,7 @@
+"use client";
+
+import { SessionProvider } from "next-auth/react";
+
+export function Providers({ children }: { children: React.ReactNode }) {
+  return <SessionProvider>{children}</SessionProvider>;
+}

app/refund/page.tsx

@@ -0,0 +1,106 @@
+import type { Metadata } from "next";
+import Link from "next/link";
+import { LegalPageLayout } from "@/components/LegalPageLayout";
+import { LEGAL_OPERATOR } from "@/lib/legal/constants";
+
+export const metadata: Metadata = {
+  title: "Refund Policy | Songs2YT",
+  description: "Refund and cancellation policy for Songs2YT paid plans.",
+};
+
+export default function RefundPage() {
+  return (
+    <LegalPageLayout
+      title="Refund Policy"
+      description="Our policy on refunds, cancellations, and billing for paid plans."
+    >
+      <h2>1. Overview</h2>
+      <p>
+        This Refund Policy explains how refunds and cancellations work for paid Songs2YT plans. The
+        free Bedroom Producer plan does not involve payments and is not subject to refunds.
+      </p>
+
+      <h2>2. Free plan</h2>
+      <p>
+        The free plan is provided at no charge. No payment information is required and no refunds
+        apply.
+      </p>
+
+      <h2>3. Pro subscriptions</h2>
+      <h3>3.1 Billing cycle</h3>
+      <p>
+        Pro plans are billed on a recurring monthly basis unless otherwise stated at checkout.
+        Your subscription renews automatically until cancelled.
+      </p>
+
+      <h3>3.2 14-day refund window</h3>
+      <p>
+        If you are a new Pro subscriber, you may request a full refund within <strong>14 days</strong> of
+        your initial purchase, provided you have not substantially consumed paid entitlements
+        (for example, a large portion of your monthly video quota or premium-only features).
+      </p>
+
+      <h3>3.3 After the refund window</h3>
+      <p>
+        After 14 days, subscription fees are generally non-refundable for the current billing
+        period. You may cancel at any time to prevent future renewals. Access typically continues
+        until the end of the paid period.
+      </p>
+
+      <h3>3.4 Cancellation</h3>
+      <p>
+        You can cancel your subscription through your account billing settings or by contacting{" "}
+        <a href={`mailto:${LEGAL_OPERATOR.email}`}>{LEGAL_OPERATOR.email}</a>. Cancellation stops
+        future charges; it does not automatically delete your account or uploaded content history
+        unless you request account deletion separately.
+      </p>
+
+      <h2>4. Enterprise and custom agreements</h2>
+      <p>
+        Enterprise, managed cloud, and paid self-hosted setup fees are governed by the individual
+        quote or contract signed with us. Refund terms for those services are specified in your
+        agreement. Contact{" "}
+        <a href={`mailto:${LEGAL_OPERATOR.salesEmail}`}>{LEGAL_OPERATOR.salesEmail}</a> for
+        contract-related billing questions.
+      </p>
+
+      <h2>5. Non-refundable situations</h2>
+      <p>Refunds are generally not provided when:</p>
+      <ul>
+        <li>The refund request is made outside the applicable refund window</li>
+        <li>The account was terminated for violation of our <Link href="/terms">Terms of Service</Link></li>
+        <li>The issue is caused by third-party services outside our control (e.g. YouTube API outages, Google account restrictions)</li>
+        <li>You simply changed your mind after substantial use of paid quota or features</li>
+        <li>One-time setup or license fees after delivery of agreed setup work, unless required by law or contract</li>
+      </ul>
+
+      <h2>6. Chargebacks</h2>
+      <p>
+        If you believe a charge is incorrect, please contact us before initiating a chargeback so
+        we can resolve the issue promptly. Unjustified chargebacks may result in account suspension.
+      </p>
+
+      <h2>7. How to request a refund</h2>
+      <p>Email us at <a href={`mailto:${LEGAL_OPERATOR.email}`}>{LEGAL_OPERATOR.email}</a> with:</p>
+      <ul>
+        <li>Your account email address</li>
+        <li>Date of purchase and invoice or transaction reference if available</li>
+        <li>Reason for the refund request</li>
+      </ul>
+      <p>We aim to respond within 5 business days. Approved refunds are issued to the original payment method where possible.</p>
+
+      <h2>8. Consumer rights</h2>
+      <p>
+        Nothing in this policy limits mandatory statutory rights you may have as a consumer under
+        applicable law, including withdrawal rights where required by EU or local consumer
+        protection regulations.
+      </p>
+
+      <h2>9. Changes</h2>
+      <p>
+        We may update this Refund Policy from time to time. The version published on this page
+        applies to purchases made after the effective date shown at the top.
+      </p>
+    </LegalPageLayout>
+  );
+}

app/terms/page.tsx

@@ -0,0 +1,198 @@
+import type { Metadata } from "next";
+import Link from "next/link";
+import { LegalPageLayout } from "@/components/LegalPageLayout";
+import { LEGAL_OPERATOR } from "@/lib/legal/constants";
+
+export const metadata: Metadata = {
+  title: "Terms of Service | Songs2YT",
+  description: "Terms and conditions for using the Songs2YT hosted service.",
+};
+
+export default function TermsPage() {
+  return (
+    <LegalPageLayout
+      title="Terms of Service"
+      description="Please read these terms carefully before using Songs2YT."
+    >
+      <h2>1. Agreement</h2>
+      <p>
+        These Terms of Service (&quot;Terms&quot;) govern your access to and use of the Songs2YT
+        website and hosted cloud service (the &quot;Service&quot;) operated by{" "}
+        {LEGAL_OPERATOR.legalName} (&quot;we&quot;, &quot;us&quot;). By creating an account or using
+        the Service, you agree to these Terms.
+      </p>
+      <p>
+        If you do not agree, do not use the Service. If you self-host the open-source software on
+        your own infrastructure without using our hosted Service, these Terms apply only to the
+        extent you use our website, support channels, or paid services we provide.
+      </p>
+
+      <h2>2. The Service</h2>
+      <p>
+        Songs2YT converts user-provided images and audio files into videos and can upload them to
+        YouTube using your connected Google/YouTube account. Features, limits, and availability
+        depend on your plan.
+      </p>
+      <ul>
+        <li>
+          <strong>Bedroom Producer (Free):</strong> limited quota, 720p, MP3, optional watermark
+        </li>
+        <li>
+          <strong>Independent Artist (Pro):</strong> expanded limits and features as described on
+          our pricing page
+        </li>
+        <li>
+          <strong>Enterprise:</strong> custom terms as agreed in writing
+        </li>
+      </ul>
+      <p>
+        We may modify features, limits, or pricing with reasonable notice where required. The
+        open-source software is provided separately under its applicable open-source license.
+      </p>
+
+      <h2>3. Eligibility and accounts</h2>
+      <ul>
+        <li>You must be at least 16 years old or the age required in your jurisdiction</li>
+        <li>You must have a valid Google account and authorized access to the YouTube channel you connect</li>
+        <li>You are responsible for maintaining the security of your account and OAuth connection</li>
+        <li>You must provide accurate information and promptly update it if it changes</li>
+      </ul>
+
+      <h2>4. Your content and responsibilities</h2>
+      <p>You retain ownership of content you upload. You grant us a limited license to host, process, encode, transmit, and upload your content solely to provide the Service.</p>
+      <p>You represent and warrant that:</p>
+      <ul>
+        <li>You own or have all necessary rights to the content you upload</li>
+        <li>Your content and use of the Service comply with applicable law and YouTube policies</li>
+        <li>Your content does not infringe third-party rights or contain unlawful material</li>
+        <li>You have configured metadata (including &quot;Made for Kids&quot; and privacy settings) accurately</li>
+      </ul>
+      <p>
+        You are solely responsible for content published to your YouTube channel through the
+        Service.
+      </p>
+
+      <h2>5. Acceptable use</h2>
+      <p>You agree not to:</p>
+      <ul>
+        <li>Use the Service for unlawful, harmful, or abusive purposes</li>
+        <li>Upload malware, attempt unauthorized access, or interfere with the Service</li>
+        <li>Circumvent quotas, plan limits, or technical restrictions</li>
+        <li>Resell or commercially exploit the hosted Service without authorization</li>
+        <li>Use the Service in a way that violates Google, YouTube, or third-party terms</li>
+      </ul>
+      <p>We may suspend or terminate access for violations or risks to the Service or other users.</p>
+
+      <h2>6. YouTube and third-party services</h2>
+      <p>
+        The Service integrates with Google OAuth and the YouTube API. Your use of those services is
+        subject to Google&apos;s and YouTube&apos;s terms and policies. We are not responsible for
+        changes, outages, quota limits, or enforcement actions taken by YouTube.
+      </p>
+
+      <h2>7. Open-source software</h2>
+      <p>
+        Portions of Songs2YT are available as open-source software. Self-hosting is permitted under
+        the applicable open-source license. The hosted Service, enterprise features, managed
+        infrastructure, and certain premium capabilities may require a separate commercial license
+        or subscription.
+      </p>
+
+      <h2>8. Fees and billing</h2>
+      <p>
+        Paid plans are billed according to the pricing displayed at the time of purchase. Taxes may
+        apply. Subscriptions renew automatically unless cancelled in accordance with our{" "}
+        <Link href="/refund">Refund Policy</Link>. Failure to pay may result in downgrade or
+        suspension.
+      </p>
+
+      <h3>8.1 Pro plan quota</h3>
+      <p>
+        Independent Artist (Pro) subscribers receive a monthly video quota that resets on the{" "}
+        <strong>1st day of each calendar month</strong> (UTC). Unused quota does not roll over to
+        the next month unless we expressly grant an extension in writing.
+      </p>
+      <p>
+        Pro subscribers may contact{" "}
+        <a href={`mailto:${LEGAL_OPERATOR.email}`}>{LEGAL_OPERATOR.email}</a> to request a manual
+        quota reset or temporary extension. Each Pro account is entitled to up to{" "}
+        <strong>five (5) manual monthly quota resets per calendar year</strong>. We review requests
+        in good faith and may decline requests that are abusive, repetitive without cause, or
+        inconsistent with fair use. Approved resets do not increase the annual limit of five
+        requests.
+      </p>
+
+      <h3>8.2 Pro API access</h3>
+      <p>
+        Independent Artist (Pro) subscribers may generate an API key in account settings to upload
+        files and create batch video jobs programmatically. API access requires an active Pro
+        subscription, a connected YouTube account, and compliance with the same quota, file-type, and
+        resolution limits as the web interface. API keys are personal, must be kept confidential, and
+        may be revoked by you or by us if misused. We may apply rate limits and suspend API access
+        for abuse, security incidents, or plan downgrades.
+      </p>
+
+      <h2>9. Availability and support</h2>
+      <p>
+        We strive for high availability but do not guarantee uninterrupted access. Maintenance,
+        updates, and outages may occur. Support levels depend on your plan. Self-hosted DIY
+        deployments without a paid setup are community-supported unless otherwise agreed in
+        writing.
+      </p>
+
+      <h2>10. Disclaimer of warranties</h2>
+      <p>
+        THE SERVICE IS PROVIDED &quot;AS IS&quot; AND &quot;AS AVAILABLE&quot; TO THE MAXIMUM EXTENT
+        PERMITTED BY LAW. WE DISCLAIM ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. WE DO NOT WARRANT THAT ENCODING,
+        UPLOADS, OR METADATA TRANSFER WILL BE ERROR-FREE OR UNINTERRUPTED.
+      </p>
+
+      <h2>11. Limitation of liability</h2>
+      <p>
+        TO THE MAXIMUM EXTENT PERMITTED BY LAW, WE SHALL NOT BE LIABLE FOR INDIRECT, INCIDENTAL,
+        SPECIAL, CONSEQUENTIAL, OR PUNITIVE DAMAGES, OR ANY LOSS OF PROFITS, REVENUE, DATA, OR
+        GOODWILL. OUR TOTAL LIABILITY FOR ANY CLAIM ARISING OUT OF THESE TERMS OR THE SERVICE IS
+        LIMITED TO THE AMOUNT YOU PAID US IN THE TWELVE (12) MONTHS BEFORE THE EVENT GIVING RISE TO
+        THE CLAIM, OR EUR 100 IF YOU USE THE FREE PLAN ONLY.
+      </p>
+      <p>
+        Some jurisdictions do not allow certain limitations, so some of the above may not apply to
+        you.
+      </p>
+
+      <h2>12. Indemnification</h2>
+      <p>
+        You agree to indemnify and hold us harmless from claims arising out of your content, your
+        use of the Service, or your violation of these Terms or applicable law.
+      </p>
+
+      <h2>13. Termination</h2>
+      <p>
+        You may stop using the Service at any time. We may suspend or terminate your access if you
+        breach these Terms, create risk or legal exposure, or where required by law. Upon
+        termination, your right to use the hosted Service ends. Provisions that by nature should
+        survive will survive.
+      </p>
+
+      <h2>14. Governing law</h2>
+      <p>
+        These Terms are governed by the laws of [Your jurisdiction / country], excluding conflict
+        of law rules. Courts in [Your jurisdiction] shall have exclusive jurisdiction unless
+        mandatory consumer protection laws in your country provide otherwise.
+      </p>
+
+      <h2>15. Changes</h2>
+      <p>
+        We may update these Terms from time to time. Continued use after changes become effective
+        constitutes acceptance of the revised Terms, where permitted by law.
+      </p>
+
+      <h2>16. Contact</h2>
+      <p>
+        Questions about these Terms:{" "}
+        <a href={`mailto:${LEGAL_OPERATOR.email}`}>{LEGAL_OPERATOR.email}</a>
+      </p>
+    </LegalPageLayout>
+  );
+}