wired blog2video api phase 1

.env.example

@@ -1,131 +0,0 @@
-# ---- App
-ENV=development
-APP_NAME=Notestack
-FRONTEND_URL=http://localhost:5173
-API_URL=http://localhost:8000
-CORS_ORIGINS=http://localhost:5173
-INTERNAL_TOKEN=replace-with-random-token
-BILLING_ENABLED=false
-# Stripe. Checkout, the customer portal and webhooks. Prices are found or created by lookup key
-# (notestack_<plan>_<cycle>) from backend/app/services/plans.py; set STRIPE_PRICE_* to pin existing ones.
-# Webhook endpoint: {API_URL}/api/billing/webhook with events checkout.session.completed,
-# checkout.session.async_payment_succeeded, checkout.session.async_payment_failed,
-# customer.subscription.created, customer.subscription.updated, customer.subscription.deleted,
-# customer.subscription.paused, customer.subscription.resumed, invoice.paid, invoice.payment_failed,
-# invoice.payment_action_required, charge.dispute.created.
-STRIPE_SECRET_KEY=
-STRIPE_WEBHOOK_SECRET=
-STRIPE_PRICE_WRITER_MONTHLY=
-STRIPE_PRICE_WRITER_ANNUAL=
-STRIPE_PRICE_STUDIO_MONTHLY=
-STRIPE_PRICE_STUDIO_ANNUAL=
-
-# ---- Auth (JWT). Revocation bumps users.token_version, so tokens can be long lived.
-JWT_SECRET=replace-with-64-random-chars
-JWT_ALGORITHM=HS256
-JWT_EXPIRATION_HOURS=72
-JWT_REFRESH_EXPIRATION_DAYS=30
-
-# ---- Database (also backs the job queue)
-# Local: a SQLite file, created by `alembic upgrade head` run from backend/.
-# Prod (Neon, Supabase, RDS...): Postgres with the psycopg driver, e.g.
-#   DATABASE_URL=postgresql+psycopg://user:pass@host:5432/dbname?sslmode=require
-# docker-compose ignores this and points at its own Postgres container.
-DATABASE_URL=sqlite:///./notestack.db
-
-# ---- Google sign in (OAuth client, type Web; add http://localhost:5173 to authorized JS origins)
-# Client ID only: popup sign in (Google Identity Services), no redirect URIs needed.
-# Client ID + secret: redirect flow with server side code exchange. Add the redirect URI
-# (default {API_URL}/api/auth/google/callback, e.g. http://localhost:8000/api/auth/google/callback)
-# to "Authorized redirect URIs" on the OAuth client. Never prefix the secret with VITE_.
-GOOGLE_CLIENT_ID=
-GOOGLE_CLIENT_SECRET=
-GOOGLE_REDIRECT_URI=
-
-# ---- Email (Resend). EMAIL_PROVIDER=console prints emails to the API log instead.
-EMAIL_PROVIDER=console
-RESEND_API_KEY=
-FROM_EMAIL=Notestack <hello@notestack.ai>
-ALERTS_EMAIL=arslan@firebird-technologies.com
-UNSUBSCRIBE_SECRET=replace-me
-# Hour (UTC, 0 to 23) at which scheduled update email campaigns send their daily batch.
-UPDATE_EMAIL_SEND_HOUR=9
-
-# ---- Local dev conveniences
-# The API runs the job worker in process when ENV=development (set false to use python -m app.worker).
-RUN_WORKER_IN_API=
-# auto = local disk (LOCAL_STORAGE_DIR) when no R2 account or endpoint is set, else R2
-STORAGE_BACKEND=auto
-LOCAL_STORAGE_DIR=.storage
-
-# ---- Storage: Cloudflare R2
-# Prod: set account id + keys, leave R2_ENDPOINT_URL empty.
-# Local: docker-compose points R2_ENDPOINT_URL at MinIO (keys minioadmin/minioadmin).
-R2_ACCOUNT_ID=
-R2_ACCESS_KEY_ID=minioadmin
-R2_SECRET_ACCESS_KEY=minioadmin
-R2_BUCKET=notestack-assets
-R2_ENDPOINT_URL=
-R2_PUBLIC_BASE_URL=
-# Folder inside the bucket when it is shared with other apps, e.g. notestack. Empty = bucket root.
-R2_PREFIX=
-# How long presigned download links stay valid, in seconds.
-R2_PRESIGN_TTL_SECONDS=3600
-# Largest file a browser may upload (bytes). 209715200 = 200 MB.
-MAX_UPLOAD_BYTES=209715200
-
-# ---- LLM (any LiteLLM model string). Defaults target Z.ai GLM-5.3 via its OpenAI compatible API.
-# GLM-5.x always reasons; LLM_REASONING_EFFORT (low | high | max) trades cost for depth.
-# Cheaper: LLM_MODEL=openai/glm-5.3-flash. Free for local dev: openai/glm-4.7-flash
-LLM_MODEL=openai/glm-5.3
-LLM_FAST_MODEL=openai/glm-5.3-flash
-LLM_API_BASE=https://api.z.ai/api/paas/v4
-LLM_API_KEY=
-LLM_TEMPERATURE=1.0
-LLM_MAX_TOKENS=16000
-LLM_REASONING_EFFORT=low
-# Fallback chat triage model when Jev is not configured. Empty = LLM_FAST_MODEL.
-LLM_TRIAGE_MODEL=
-
-# ---- Chat triage: TypeSafe Jev (https://typesafe.ai)
-# A fast classifier (typed choices, no text generation) that decides what each chat message needs
-# before any research runs. With a key set, greetings, off topic and app questions never reach the
-# LLM, and archive questions get a quick or deep research budget. Empty = LLM triage above.
-TYPESAFE_API_KEY=
-TYPESAFE_MODEL=jev-latest
-TYPESAFE_URL=https://api.typesafe.ai
-
-# Firecrawl (firecrawl.dev): lets Connect read sites with no RSS feed, including JavaScript sites
-# (Next.js, Framer, Webflow), and makes single URL imports reliable. Empty = plain HTTP fetching only.
-FIRECRAWL_API_KEY=
-
-# ---- Research corpus (posts as markdown files; the agent greps and reads them, no vector index)
-CORPUS_CACHE_DIR=.corpus-cache
-RESEARCH_MAX_STEPS=10
-
-# ---- Worker (jobs queue lives in the database; no Redis)
-WORKER_CONCURRENCY=4
-WORKER_POLL_SECONDS=1
-JOB_STALE_SECONDS=900
-
-# ---- ElevenLabs (audio overviews, video narration, voice cloning)
-ELEVENLABS_API_KEY=
-ELEVENLABS_MODEL=eleven_multilingual_v2
-ELEVENLABS_VOICE_A=EXAVITQu4vr4xnSDxMaL
-ELEVENLABS_VOICE_B=JBFqnCBsd6RMkjVDRZzb
-
-# ---- Renderer (Remotion service for videos, quote cards and carousels: cd renderer && npm start)
-RENDERER_URL=http://localhost:3100
-
-# ---- Launchpad social publishing
-# Bluesky needs nothing here (users connect with an app password).
-# X: developer app with OAuth 2.0, type Web App, scopes tweet.read tweet.write users.read offline.access.
-#   Callback URI: {API_URL}/api/social/x/callback  e.g. http://localhost:8000/api/social/x/callback
-# LinkedIn: app with the "Sign In with LinkedIn using OpenID Connect" and "Share on LinkedIn" products.
-#   Redirect URL: {API_URL}/api/social/linkedin/callback
-X_CLIENT_ID=
-X_CLIENT_SECRET=
-LINKEDIN_CLIENT_ID=
-LINKEDIN_CLIENT_SECRET=
-# Fernet key for stored social tokens; derived from JWT_SECRET when empty.
-SOCIAL_TOKEN_KEY=

backend/alembic/versions/0005_video_quota.py

@@ -0,0 +1,48 @@
+"""subscriptions.video_plan / videos_used / video_limit / videos_period_start: the video allowance
+
+Revision ID: 0005_video_quota
+Revises: 0004_archive_notebook
+Create Date: 2026-09-29
+"""
+import sqlalchemy as sa
+from alembic import op
+
+revision = "0005_video_quota"
+down_revision = "0004_archive_notebook"
+branch_labels = None
+depends_on = None
+
+COLUMNS = ("video_plan", "videos_used", "video_limit", "videos_period_start")
+
+
+def upgrade() -> None:
+    # 0001 builds from the live models, so a fresh database may already have the columns.
+    existing = {c["name"] for c in sa.inspect(op.get_bind()).get_columns("subscriptions")}
+    new = {
+        "video_plan": sa.Column("video_plan", sa.String(20), nullable=False, server_default="free"),
+        "videos_used": sa.Column("videos_used", sa.Integer(), nullable=False, server_default="0"),
+        "video_limit": sa.Column("video_limit", sa.Integer(), nullable=False, server_default="0"),
+        "videos_period_start": sa.Column("videos_period_start", sa.DateTime(timezone=True), nullable=True),
+    }
+    missing = [new[name] for name in COLUMNS if name not in existing]
+    if missing:
+        with op.batch_alter_table("subscriptions") as batch:
+            for column in missing:
+                batch.add_column(column)
+    # Same limits as app/services/plans.py; the app re-syncs on first use (billing disabled -> studio).
+    op.execute("""
+        UPDATE subscriptions SET
+          video_plan = CASE WHEN status IN ('active', 'trialing', 'past_due') AND plan IN ('writer', 'studio')
+                            THEN plan ELSE 'free' END
+    """)
+    op.execute("""
+        UPDATE subscriptions SET
+          video_limit = CASE video_plan WHEN 'studio' THEN 30 WHEN 'writer' THEN 10 ELSE 1 END,
+          videos_period_start = COALESCE(videos_period_start, CURRENT_TIMESTAMP)
+    """)
+
+
+def downgrade() -> None:
+    with op.batch_alter_table("subscriptions") as batch:
+        for name in reversed(COLUMNS):
+            batch.drop_column(name)

backend/alembic/versions/0006_plans.py

@@ -0,0 +1,71 @@
+"""plans: one row per plan (limits, price, pricing-page copy), editable without a deploy
+
+Seeded with the plans that were hard-coded in app/services/plans.py. Rows that already exist are left alone.
+
+Revision ID: 0006_plans
+Revises: 0005_video_quota
+Create Date: 2026-09-29
+"""
+from datetime import UTC, datetime
+
+import sqlalchemy as sa
+from alembic import op
+
+revision = "0006_plans"
+down_revision = "0005_video_quota"
+branch_labels = None
+depends_on = None
+
+SEED = [
+    {"id": "free", "sort_order": 0, "name": "Free", "tagline": "For trying Notestack on your archive",
+     "price_monthly_usd": 0, "sources": 1, "indexed_posts": 5, "audio_minutes": 3, "videos": 1, "launch_kits": 2,
+     "voice_cloning": False, "brand_kit": False,
+     "features": ["1 source, your latest 5 posts indexed", "Grounded research chat with citations",
+                  "3 min of audio overviews a month", "1 video a month", "2 Launch Kits a month"]},
+    {"id": "writer", "sort_order": 1, "name": "Writer", "tagline": "For writers publishing every week",
+     "price_monthly_usd": 24.99, "sources": 3, "indexed_posts": 500, "audio_minutes": 60, "videos": 10,
+     "launch_kits": 50, "voice_cloning": True, "brand_kit": True,
+     "features": ["3 sources, 500 indexed posts", "60 min of audio overviews a month", "10 videos a month",
+                  "50 Launch Kits a month", "Voice cloning with consent", "Your brand colors and logo"]},
+    {"id": "studio", "sort_order": 2, "name": "Studio", "tagline": "For publications and power users",
+     "price_monthly_usd": 48.99, "sources": 10, "indexed_posts": 5000, "audio_minutes": 240, "videos": 30,
+     "launch_kits": -1, "voice_cloning": True, "brand_kit": True,
+     "features": ["10 sources, 5,000 indexed posts", "240 min of audio overviews a month", "30 videos a month",
+                  "Unlimited Launch Kits", "Launchpad calendar and resurfacing", "Priority rendering"]},
+]
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    # 0001 builds from the live models, so a fresh database may already have the table (empty).
+    if "plans" not in sa.inspect(bind).get_table_names():
+        op.create_table(
+            "plans",
+            sa.Column("id", sa.String(20), primary_key=True),
+            sa.Column("sort_order", sa.Integer(), nullable=False, server_default="0"),
+            sa.Column("name", sa.String(50), nullable=False),
+            sa.Column("tagline", sa.String(200), nullable=False, server_default=""),
+            sa.Column("price_monthly_usd", sa.Float(), nullable=False, server_default="0"),
+            sa.Column("sources", sa.Integer(), nullable=False, server_default="1"),
+            sa.Column("indexed_posts", sa.Integer(), nullable=False, server_default="5"),
+            sa.Column("audio_minutes", sa.Integer(), nullable=False, server_default="0"),
+            sa.Column("videos", sa.Integer(), nullable=False, server_default="0"),
+            sa.Column("launch_kits", sa.Integer(), nullable=False, server_default="0"),
+            sa.Column("voice_cloning", sa.Boolean(), nullable=False, server_default=sa.false()),
+            sa.Column("brand_kit", sa.Boolean(), nullable=False, server_default=sa.false()),
+            sa.Column("features", sa.JSON(), nullable=False),
+            sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
+            sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False),
+        )
+    types = {"features": sa.JSON(), "voice_cloning": sa.Boolean(), "brand_kit": sa.Boolean(),
+             "created_at": sa.DateTime(timezone=True), "updated_at": sa.DateTime(timezone=True)}
+    plans = sa.table("plans", *(sa.column(k, types.get(k)) for k in [*SEED[0], "created_at", "updated_at"]))
+    existing = {row[0] for row in bind.execute(sa.text("SELECT id FROM plans"))}
+    now = datetime.now(UTC)
+    missing = [{**p, "created_at": now, "updated_at": now} for p in SEED if p["id"] not in existing]
+    if missing:
+        op.bulk_insert(plans, missing)
+
+
+def downgrade() -> None:
+    op.drop_table("plans")

backend/alembic/versions/0007_subscription_plan_fk.py

@@ -0,0 +1,36 @@
+"""subscriptions.plan -> plans.id: the plan is picked from the plans table, not typed as free text
+
+Unknown plan values (typos, removed plans) become 'free' first so the constraint can be added.
+
+Revision ID: 0007_subscription_plan_fk
+Revises: 0006_plans
+Create Date: 2026-09-29
+"""
+import sqlalchemy as sa
+from alembic import op
+
+revision = "0007_subscription_plan_fk"
+down_revision = "0006_plans"
+branch_labels = None
+depends_on = None
+
+NAME = "fk_subscriptions_plan_plans"
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    # 0001 builds from the live models, so a fresh database may already have the constraint.
+    if any(fk["referred_table"] == "plans" for fk in sa.inspect(bind).get_foreign_keys("subscriptions")):
+        return
+    op.execute("UPDATE subscriptions SET plan = 'free' WHERE plan IS NULL OR plan NOT IN (SELECT id FROM plans)")
+    with op.batch_alter_table("subscriptions") as batch:
+        batch.create_foreign_key(NAME, "plans", ["plan"], ["id"], onupdate="CASCADE")
+
+
+def downgrade() -> None:
+    fks = sa.inspect(op.get_bind()).get_foreign_keys("subscriptions")
+    name = next((fk["name"] for fk in fks if fk["referred_table"] == "plans"), None)
+    if not name:
+        return  # unnamed (built by 0001 on SQLite): nothing we can drop by name
+    with op.batch_alter_table("subscriptions") as batch:
+        batch.drop_constraint(name, type_="foreignkey")

backend/alembic/versions/0008_b2v_videos.py

@@ -0,0 +1,40 @@
+"""b2v_videos: which workspace owns each blog2video video, and whether its allowance is still charged
+
+blog2video now only takes our account's API key, so this table is our access control and refund ledger.
+blog2video no longer connects to this database: drop the role it used (see docs/BLOG2VIDEO.md).
+
+Revision ID: 0008_b2v_videos
+Revises: 0007_subscription_plan_fk
+Create Date: 2026-09-30
+"""
+import sqlalchemy as sa
+from alembic import op
+
+revision = "0008_b2v_videos"
+down_revision = "0007_subscription_plan_fk"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # 0001 builds from the live models, so a fresh database may already have the table.
+    if sa.inspect(op.get_bind()).has_table("b2v_videos"):
+        return
+    op.create_table(
+        "b2v_videos",
+        sa.Column("id", sa.Uuid(), primary_key=True),
+        sa.Column("workspace_id", sa.Uuid(), sa.ForeignKey("workspaces.id", ondelete="CASCADE"), nullable=False),
+        sa.Column("artifact_id", sa.Uuid(), sa.ForeignKey("artifacts.id", ondelete="SET NULL"), nullable=True),
+        sa.Column("b2v_video_id", sa.Integer(), nullable=True, unique=True),
+        sa.Column("idempotency_key", sa.String(100), nullable=False, unique=True),
+        sa.Column("quota_state", sa.String(20), nullable=False, server_default="charged"),
+        sa.Column("status", sa.String(40), nullable=False, server_default="queued"),
+        sa.Column("created_at", sa.DateTime(timezone=True), nullable=False, server_default=sa.func.now()),
+        sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False, server_default=sa.func.now()),
+    )
+    op.create_index("ix_b2v_videos_ws_created", "b2v_videos", ["workspace_id", "created_at"])
+    op.create_index("ix_b2v_videos_artifact_id", "b2v_videos", ["artifact_id"])
+
+
+def downgrade() -> None:
+    op.drop_table("b2v_videos")

backend/alembic/versions/0009_b2v_resources.py

@@ -0,0 +1,111 @@
+"""blog2video resources per workspace: templates, custom voices, saved voices, styles, usage counters;
+b2v_videos.created_via / template_ref; plans.video_premium / video_limits
+
+Everything made with our blog2video key belongs to one account, so these tables are what keeps each workspace's
+templates, voices and styles its own (app/services/b2v_access.py).
+
+Revision ID: 0009_b2v_resources
+Revises: 0008_b2v_videos
+Create Date: 2026-09-30
+"""
+import json
+
+import sqlalchemy as sa
+from alembic import op
+
+revision = "0009_b2v_resources"
+down_revision = "0008_b2v_videos"
+branch_labels = None
+depends_on = None
+
+# Same as app/services/plans.py
+VIDEO_LIMITS = {
+    "free": {"ai_edits": 20, "templates": 0, "template_ai_daily": 0, "voice_designs_daily": 0,
+             "voice_samples_daily": 0, "custom_voices": 0},
+    "writer": {"ai_edits": 300, "templates": 2, "template_ai_daily": 3, "voice_designs_daily": 5,
+               "voice_samples_daily": 20, "custom_voices": 3},
+    "studio": {"ai_edits": 1000, "templates": 5, "template_ai_daily": 5, "voice_designs_daily": 10,
+               "voice_samples_daily": 40, "custom_voices": 10},
+}
+
+
+def _ws() -> sa.Column:
+    return sa.Column("workspace_id", sa.Uuid(), sa.ForeignKey("workspaces.id", ondelete="CASCADE"), nullable=False,
+                     index=True)
+
+
+def _times() -> list[sa.Column]:
+    return [sa.Column("created_at", sa.DateTime(timezone=True), nullable=False, server_default=sa.func.now()),
+            sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False, server_default=sa.func.now())]
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    inspector = sa.inspect(bind)
+
+    # 0001 builds from the live models, so a fresh database may already have all of this.
+    video_cols = {c["name"] for c in inspector.get_columns("b2v_videos")}
+    with op.batch_alter_table("b2v_videos") as batch:
+        if "created_via" not in video_cols:
+            batch.add_column(sa.Column("created_via", sa.String(10), nullable=False, server_default="v1"))
+        if "template_ref" not in video_cols:
+            batch.add_column(sa.Column("template_ref", sa.String(100), nullable=True))
+        batch.alter_column("idempotency_key", existing_type=sa.String(100), nullable=True)
+
+    if not inspector.has_table("b2v_templates"):
+        op.create_table("b2v_templates",
+                        sa.Column("b2v_template_id", sa.Integer(), primary_key=True, autoincrement=False), _ws(),
+                        sa.Column("name", sa.String(255), nullable=False),
+                        sa.Column("ready", sa.Boolean(), nullable=False, server_default=sa.false()), *_times())
+    if not inspector.has_table("b2v_custom_voices"):
+        op.create_table("b2v_custom_voices",
+                        sa.Column("b2v_custom_voice_id", sa.Integer(), primary_key=True, autoincrement=False), _ws(),
+                        sa.Column("voice_id", sa.String(100), nullable=False, unique=True),
+                        sa.Column("name", sa.String(255), nullable=False),
+                        sa.Column("source", sa.String(20), nullable=False),
+                        sa.Column("preview_url", sa.String(1000), nullable=True), *_times())
+    if not inspector.has_table("user_saved_voices"):
+        op.create_table("user_saved_voices",
+                        sa.Column("workspace_id", sa.Uuid(), sa.ForeignKey("workspaces.id", ondelete="CASCADE"),
+                                  primary_key=True),
+                        sa.Column("voice_id", sa.String(100), primary_key=True),
+                        sa.Column("name", sa.String(255), nullable=False),
+                        sa.Column("preview_url", sa.String(1000), nullable=True),
+                        sa.Column("gender", sa.String(20), nullable=True),
+                        sa.Column("accent", sa.String(50), nullable=True),
+                        sa.Column("premium", sa.Boolean(), nullable=False, server_default=sa.false()),
+                        sa.Column("is_custom", sa.Boolean(), nullable=False, server_default=sa.false()), *_times())
+    if not inspector.has_table("b2v_styles"):
+        op.create_table("b2v_styles",
+                        sa.Column("b2v_style_id", sa.Integer(), primary_key=True, autoincrement=False), _ws(),
+                        sa.Column("name", sa.String(80), nullable=False), *_times())
+    if not inspector.has_table("usage_counters"):
+        op.create_table("usage_counters",
+                        sa.Column("workspace_id", sa.Uuid(), sa.ForeignKey("workspaces.id", ondelete="CASCADE"),
+                                  primary_key=True),
+                        sa.Column("period", sa.String(10), primary_key=True),
+                        sa.Column("metric", sa.String(30), primary_key=True),
+                        sa.Column("used", sa.Integer(), nullable=False, server_default="0"))
+
+    plan_cols = {c["name"] for c in inspector.get_columns("plans")}
+    with op.batch_alter_table("plans") as batch:
+        if "video_premium" not in plan_cols:
+            batch.add_column(sa.Column("video_premium", sa.Boolean(), nullable=False, server_default=sa.false()))
+        if "video_limits" not in plan_cols:
+            batch.add_column(sa.Column("video_limits", sa.JSON(), nullable=True))
+    plans = sa.table("plans", sa.column("id", sa.String), sa.column("video_premium", sa.Boolean),
+                     sa.column("video_limits", sa.JSON))
+    for plan_id, limits in VIDEO_LIMITS.items():
+        op.execute(plans.update().where(plans.c.id == plan_id)
+                   .values(video_premium=plan_id != "free", video_limits=json.loads(json.dumps(limits))))
+
+
+def downgrade() -> None:
+    with op.batch_alter_table("plans") as batch:
+        batch.drop_column("video_limits")
+        batch.drop_column("video_premium")
+    for table in ("usage_counters", "b2v_styles", "user_saved_voices", "b2v_custom_voices", "b2v_templates"):
+        op.drop_table(table)
+    with op.batch_alter_table("b2v_videos") as batch:
+        batch.drop_column("template_ref")
+        batch.drop_column("created_via")

backend/alembic/versions/0010_b2v_video_refs.py

@@ -0,0 +1,96 @@
+"""b2v_videos holds each video's full reference (who made it, title, source, links); video limits 1 total / 10 / 20
+
+- b2v_videos: user_id, title, source_url, aspect_ratio, preview_url, video_url, backfilled from the workspace owner
+  and the linked artifact.
+- plans: videos_monthly (False on Free: 1 video in total, never refilled); Studio 20 videos a month.
+
+Revision ID: 0010_b2v_video_refs
+Revises: 0009_b2v_resources
+Create Date: 2026-09-30
+"""
+import json
+
+import sqlalchemy as sa
+from alembic import op
+
+revision = "0010_b2v_video_refs"
+down_revision = "0009_b2v_resources"
+branch_labels = None
+depends_on = None
+
+VIDEO_COLUMNS = {
+    "user_id": lambda: sa.Column("user_id", sa.Uuid(), nullable=True),
+    "title": lambda: sa.Column("title", sa.String(300), nullable=True),
+    "source_url": lambda: sa.Column("source_url", sa.String(2000), nullable=True),
+    "aspect_ratio": lambda: sa.Column("aspect_ratio", sa.String(20), nullable=True),
+    "preview_url": lambda: sa.Column("preview_url", sa.String(1000), nullable=True),
+    "video_url": lambda: sa.Column("video_url", sa.String(1000), nullable=True),
+}
+
+# Same as app/services/plans.py
+PLAN_VIDEOS = {"free": (1, False, "1 video a month", "1 video to try it"),
+               "writer": (10, True, None, None),
+               "studio": (20, True, "30 videos a month", "20 videos a month")}
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    inspector = sa.inspect(bind)
+
+    # 0001 builds from the live models, so a fresh database may already have these columns.
+    existing = {c["name"] for c in inspector.get_columns("b2v_videos")}
+    missing = [make() for name, make in VIDEO_COLUMNS.items() if name not in existing]
+    if missing:
+        with op.batch_alter_table("b2v_videos") as batch:
+            for column in missing:
+                batch.add_column(column)
+            if "user_id" not in existing:
+                batch.create_foreign_key("fk_b2v_videos_user_id_users", "users", ["user_id"], ["id"],
+                                         ondelete="SET NULL")
+                batch.create_index("ix_b2v_videos_user_id", ["user_id"])
+
+    # Backfill: the workspace owner made it; title and links come from the artifact.
+    rows = bind.execute(sa.text("""
+        SELECT v.id, w.owner_id, a.content_json FROM b2v_videos v
+        JOIN workspaces w ON w.id = v.workspace_id
+        LEFT JOIN artifacts a ON a.id = v.artifact_id
+        WHERE v.user_id IS NULL
+    """)).fetchall()
+    for vid, owner_id, content in rows:
+        c = content if isinstance(content, dict) else json.loads(content or "{}")
+        bind.execute(sa.text("""
+            UPDATE b2v_videos SET user_id = :u, title = COALESCE(title, :t), aspect_ratio = COALESCE(aspect_ratio, :ar),
+                   preview_url = COALESCE(preview_url, :p), video_url = COALESCE(video_url, :v) WHERE id = :id
+        """), {"u": owner_id, "t": (c.get("title") or None), "ar": c.get("aspect_ratio"), "p": c.get("preview_url"),
+               "v": c.get("video_url"), "id": vid})
+
+    plan_cols = {c["name"] for c in inspector.get_columns("plans")}
+    if "videos_monthly" not in plan_cols:
+        with op.batch_alter_table("plans") as batch:
+            batch.add_column(sa.Column("videos_monthly", sa.Boolean(), nullable=False, server_default=sa.true()))
+    for plan_id, (videos, monthly, old, new) in PLAN_VIDEOS.items():
+        row = bind.execute(sa.text("SELECT features FROM plans WHERE id = :id"), {"id": plan_id}).fetchone()
+        if row is None:
+            continue
+        features = row[0] if isinstance(row[0], list) else json.loads(row[0] or "[]")
+        if old:
+            features = [new if f == old else f for f in features]
+        bind.execute(sa.text("UPDATE plans SET videos = :v, videos_monthly = :m, features = :f WHERE id = :id"),
+                     {"v": videos, "m": monthly, "f": json.dumps(features), "id": plan_id})
+
+
+def downgrade() -> None:
+    with op.batch_alter_table("plans") as batch:
+        batch.drop_column("videos_monthly")
+    # A database built from the models (0001) names these differently, so look them up.
+    inspector = sa.inspect(op.get_bind())
+    fks = [fk["name"] for fk in inspector.get_foreign_keys("b2v_videos")
+           if fk["constrained_columns"] == ["user_id"] and fk.get("name")]
+    indexes = [ix["name"] for ix in inspector.get_indexes("b2v_videos") if ix["column_names"] == ["user_id"]]
+    with op.batch_alter_table("b2v_videos") as batch:
+        for name in indexes:
+            batch.drop_index(name)
+        for name in fks:
+            batch.drop_constraint(name, type_="foreignkey")
+        for name in reversed(list(VIDEO_COLUMNS)):
+            batch.drop_column(name)

backend/alembic/versions/0011_one_archive_notebook.py

@@ -0,0 +1,48 @@
+"""One "All posts" notebook per workspace
+
+Two requests opening the Notebooks page at once could each create the archive notebook. This merges the copies into
+the oldest one (its posts, chats and artifacts move over) and adds a unique index so it cannot happen again.
+
+Revision ID: 0011_one_archive_notebook
+Revises: 0010_b2v_video_refs
+Create Date: 2026-10-01
+"""
+import sqlalchemy as sa
+from alembic import op
+
+revision = "0011_one_archive_notebook"
+down_revision = "0010_b2v_video_refs"
+branch_labels = None
+depends_on = None
+
+INDEX = "uq_notebooks_one_archive"
+
+
+def upgrade() -> None:
+    conn = op.get_bind()
+    rows = conn.execute(sa.text(
+        "SELECT workspace_id, id FROM notebooks WHERE is_archive ORDER BY workspace_id, created_at, id"
+    )).all()
+    keep: dict = {}
+    for ws, nb in rows:
+        if ws not in keep:
+            keep[ws] = nb
+            continue
+        ids = {"keep": keep[ws], "dup": nb}
+        conn.execute(sa.text(
+            "INSERT INTO notebook_documents (notebook_id, document_id) "
+            "SELECT :keep, document_id FROM notebook_documents WHERE notebook_id = :dup AND document_id NOT IN "
+            "(SELECT document_id FROM notebook_documents WHERE notebook_id = :keep)"
+        ), ids)
+        conn.execute(sa.text("UPDATE chats SET notebook_id = :keep WHERE notebook_id = :dup"), ids)
+        conn.execute(sa.text("UPDATE artifacts SET notebook_id = :keep WHERE notebook_id = :dup"), ids)
+        conn.execute(sa.text("DELETE FROM notebooks WHERE id = :dup"), ids)
+
+    # 0001 builds from the live models, so a fresh database may already have the index.
+    if INDEX not in {i["name"] for i in sa.inspect(conn).get_indexes("notebooks")}:
+        op.create_index(INDEX, "notebooks", ["workspace_id"], unique=True,
+                        postgresql_where=sa.text("is_archive"), sqlite_where=sa.text("is_archive"))
+
+
+def downgrade() -> None:
+    op.drop_index(INDEX, table_name="notebooks")

backend/alembic/versions/0012_artifact_status_len.py

@@ -0,0 +1,26 @@
+"""Longer artifact status
+
+A video's artifact now takes blog2video's job statuses as they are (e.g. "language_regenerating", 21 characters),
+which do not fit the old 20.
+
+Revision ID: 0012_artifact_status_len
+Revises: 0011_one_archive_notebook
+Create Date: 2026-10-02
+"""
+import sqlalchemy as sa
+from alembic import op
+
+revision = "0012_artifact_status_len"
+down_revision = "0011_one_archive_notebook"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    with op.batch_alter_table("artifacts") as batch:
+        batch.alter_column("status", existing_type=sa.String(20), type_=sa.String(40), existing_nullable=False)
+
+
+def downgrade() -> None:
+    with op.batch_alter_table("artifacts") as batch:
+        batch.alter_column("status", existing_type=sa.String(40), type_=sa.String(20), existing_nullable=False)

backend/app/config.py

@@ -101,6 +101,15 @@ class Settings(BaseSettings):
     linkedin_client_id: str = ""
     linkedin_client_secret: str = ""
 
+    # blog2video: makes the videos. We call its public API with our own account's key (b2v_live_...), so every
+    # video is charged to that account. Backend only: the key must never reach the browser or the logs.
+    b2v_api_base_url: str = Field("", validation_alias=AliasChoices("B2V_API_BASE_URL", "B2V_API_URL"))
+    b2v_api_key: str = ""
+    # blog2video's web app: serves the template poster images (<app>/template-posters/<id>.webp).
+    b2v_app_url: str = "https://blog2video.app"
+    b2v_timeout_seconds: float = 30  # creates, uploads and full-project reads; other calls also wait 30s (STATUS_TIMEOUT)
+    b2v_capacity_alert_below: int = 20  # log an error when our blog2video account has fewer videos left
+
     # Renderer
     renderer_url: str = "http://localhost:3100"
     internal_token: str = "internal-change-me"

backend/app/llm/signatures.py

@@ -47,14 +47,6 @@ class ScriptLine(BaseModel):
     sources: list[SourceRef] = Field(default_factory=list)
 
 
-class Scene(BaseModel):
-    type: Literal["title", "section", "pull_quote", "number", "outro"]
-    on_screen_text: str
-    narration: str
-    duration_hint_s: float
-    visual: str = ""
-
-
 class Hook(BaseModel):
     text: str
     strength: float = Field(ge=0, le=1)
@@ -165,14 +157,6 @@ class PodcastScript(dspy.Signature):
     lines: list[ScriptLine] = dspy.OutputField()
 
 
-class VideoStoryboard(dspy.Signature):
-    """Turn the post into a scene list for a Remotion composition."""
-
-    passages: list[str] = dspy.InputField()
-    aspect: Literal["16:9", "9:16", "1:1"] = dspy.InputField()
-    scenes: list[Scene] = dspy.OutputField()
-
-
 class HookGenerator(dspy.Signature):
     """Write scroll stopping hooks for the post in the writer's voice. No em dashes."""
 

backend/app/main.py

@@ -21,6 +21,10 @@ from app.routers import (
     storage,
     topics,
     unsubscribe,
+    video_edit,
+    video_styles,
+    video_voices,
+    videos,
     voice,
 )
 from app.routers import settings as settings_router
@@ -86,8 +90,9 @@ def health():
     return {"ok": True, "llm": settings.llm_model, "billing_enabled": settings.billing_enabled}
 
 
+# video_templates (custom templates) is switched off: users pick only from the built-in templates.
 for r in (auth, billing, storage, sources, notebooks, artifacts, jobs, unsubscribe, topics, voice, resurface,
-          launchpad, settings_router):
+          launchpad, videos, video_edit, video_voices, video_styles, settings_router):
     app.include_router(r.router)
 app.include_router(sources.documents_router)
 app.include_router(launchpad.links_router)

backend/app/models/__init__.py

@@ -1,5 +1,9 @@
 from app.models.content import (
     Artifact,
+    B2VCustomVoice,
+    B2VStyle,
+    B2VTemplate,
+    B2VVideo,
     CalendarItem,
     Chat,
     Citation,
@@ -16,16 +20,22 @@ from app.models.content import (
     Topic,
     TrackedLink,
     Upload,
+    UsageCounter,
     UsageEvent,
+    UserSavedVoice,
     VoiceConsent,
     VoiceProfile,
 )
 from app.models.email import EmailVerificationCode, UpdateEmail, UpdateEmailSend, VerificationPurpose
-from app.models.user import AuthProvider, BillingEvent, Subscription, User, Workspace, WorkspaceMember
+from app.models.user import AuthProvider, BillingEvent, PlanRecord, Subscription, User, Workspace, WorkspaceMember
 
 __all__ = [
     "Artifact",
     "AuthProvider",
+    "B2VCustomVoice",
+    "B2VStyle",
+    "B2VTemplate",
+    "B2VVideo",
     "BillingEvent",
     "CalendarItem",
     "Chat",
@@ -38,6 +48,7 @@ __all__ = [
     "Job",
     "Message",
     "Notebook",
+    "PlanRecord",
     "NotebookDocument",
     "SocialAccount",
     "Source",
@@ -47,7 +58,9 @@ __all__ = [
     "UpdateEmail",
     "UpdateEmailSend",
     "Upload",
+    "UsageCounter",
     "UsageEvent",
+    "UserSavedVoice",
     "User",
     "VerificationPurpose",
     "VoiceConsent",

backend/app/models/content.py

@@ -14,6 +14,7 @@ from sqlalchemy import (
     Text,
     UniqueConstraint,
     Uuid,
+    text,
 )
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
@@ -60,6 +61,9 @@ class Document(IdMixin, TimestampMixin, Base):
 
 class Notebook(IdMixin, TimestampMixin, Base):
     __tablename__ = "notebooks"
+    # One "All posts" notebook per workspace: two requests opening it at once cannot both create one.
+    __table_args__ = (Index("uq_notebooks_one_archive", "workspace_id", unique=True,
+                            postgresql_where=text("is_archive"), sqlite_where=text("is_archive")),)
 
     workspace_id: Mapped[uuid.UUID] = _ws_fk()
     title: Mapped[str] = mapped_column(String(300))
@@ -143,11 +147,106 @@ class Artifact(IdMixin, TimestampMixin, Base):
     document_id: Mapped[uuid.UUID | None] = mapped_column(Uuid, ForeignKey("documents.id", ondelete="SET NULL"))
     # summary | audio_overview | video | thread | linkedin | notes | quote_card | carousel | seo
     type: Mapped[str] = mapped_column(String(30))
-    status: Mapped[str] = mapped_column(String(20), default="pending")
+    # pending | generating | ready | failed | rendering | review; a video also takes blog2video's job statuses as they
+    # are: regenerating (template switch) | voice_regenerating | language_regenerating | script_regenerating
+    status: Mapped[str] = mapped_column(String(40), default="pending")
     content_json: Mapped[dict] = mapped_column(JSON, default=dict)
     storage_key: Mapped[str | None] = mapped_column(String(500))
 
 
+class B2VVideo(IdMixin, TimestampMixin, Base):
+    """One blog2video video we asked for: the only place its blog2video id lives. Every read, edit and delete on
+    blog2video goes through this row (b2v_video_id, and created_via for the right endpoints). Also records who made it
+    and whether the workspace's video allowance is still charged for it.
+
+    Our API key reaches every video it created, for every workspace, so this table (with the artifact) is what
+    ties a blog2video id to one workspace. quota_state moves charged -> refunded (or -> kept once generated), with a
+    conditional UPDATE (see video_quota.refund), so the status poller and the sweep can not refund twice."""
+
+    __tablename__ = "b2v_videos"
+    __table_args__ = (Index("ix_b2v_videos_ws_created", "workspace_id", "created_at"),)
+
+    workspace_id: Mapped[uuid.UUID] = mapped_column(Uuid, ForeignKey("workspaces.id", ondelete="CASCADE"))
+    user_id: Mapped[uuid.UUID | None] = mapped_column(Uuid, ForeignKey("users.id", ondelete="SET NULL"),
+                                                      index=True)  # who made it
+    artifact_id: Mapped[uuid.UUID | None] = mapped_column(Uuid, ForeignKey("artifacts.id", ondelete="SET NULL"),
+                                                          index=True)
+    # blog2video's video id, which is also its project id. Null until blog2video accepts the create.
+    b2v_video_id: Mapped[int | None] = mapped_column(Integer, unique=True)
+    idempotency_key: Mapped[str | None] = mapped_column(String(100), unique=True)  # "<workspace_id>:<uuid>"; v1 only
+    created_via: Mapped[str] = mapped_column(String(10), default="v1", server_default="v1")  # v1 | upload
+    template_ref: Mapped[str | None] = mapped_column(String(100))  # e.g. custom_58: blocks deleting that template
+    title: Mapped[str | None] = mapped_column(String(300))
+    source_url: Mapped[str | None] = mapped_column(String(2000))  # the link it was made from (null for files, text)
+    aspect_ratio: Mapped[str | None] = mapped_column(String(20))
+    preview_url: Mapped[str | None] = mapped_column(String(1000))  # public live preview (embed token)
+    video_url: Mapped[str | None] = mapped_column(String(1000))  # the rendered MP4
+    quota_state: Mapped[str] = mapped_column(String(20), default="charged")  # charged | refunded | kept
+    status: Mapped[str] = mapped_column(String(40), default="queued")  # last known blog2video status
+
+
+class B2VTemplate(TimestampMixin, Base):
+    """A custom template this workspace made. Used on videos as custom_<b2v_template_id>; only when ready."""
+
+    __tablename__ = "b2v_templates"
+
+    b2v_template_id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=False)
+    workspace_id: Mapped[uuid.UUID] = _ws_fk()
+    name: Mapped[str] = mapped_column(String(255))
+    ready: Mapped[bool] = mapped_column(Boolean, default=False)  # code generation finished ('complete')
+
+
+class B2VCustomVoice(TimestampMixin, Base):
+    """A designed or cloned voice this workspace made. Videos reference it by voice_id (custom_voice_id)."""
+
+    __tablename__ = "b2v_custom_voices"
+
+    b2v_custom_voice_id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=False)  # preview/delete
+    workspace_id: Mapped[uuid.UUID] = _ws_fk()
+    voice_id: Mapped[str] = mapped_column(String(100), unique=True)  # the ElevenLabs id sent as custom_voice_id
+    name: Mapped[str] = mapped_column(String(255))
+    source: Mapped[str] = mapped_column(String(20))  # prompt | preset | clone
+    preview_url: Mapped[str | None] = mapped_column(String(1000))
+
+
+class UserSavedVoice(TimestampMixin, Base):
+    """The workspace's "My voices" list. Kept only here: blog2video's saved-voice list is shared by everyone."""
+
+    __tablename__ = "user_saved_voices"
+
+    workspace_id: Mapped[uuid.UUID] = mapped_column(Uuid, ForeignKey("workspaces.id", ondelete="CASCADE"),
+                                                    primary_key=True)
+    voice_id: Mapped[str] = mapped_column(String(100), primary_key=True)
+    name: Mapped[str] = mapped_column(String(255))
+    preview_url: Mapped[str | None] = mapped_column(String(1000))
+    gender: Mapped[str | None] = mapped_column(String(20))
+    accent: Mapped[str | None] = mapped_column(String(50))
+    premium: Mapped[bool] = mapped_column(Boolean, default=False)  # a paid built-in voice, or any custom voice
+    is_custom: Mapped[bool] = mapped_column(Boolean, default=False)
+
+
+class B2VStyle(TimestampMixin, Base):
+    """A custom video style this workspace made. Used on videos as custom:<b2v_style_id>."""
+
+    __tablename__ = "b2v_styles"
+
+    b2v_style_id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=False)
+    workspace_id: Mapped[uuid.UUID] = _ws_fk()
+    name: Mapped[str] = mapped_column(String(80))
+
+
+class UsageCounter(Base):
+    """Per-workspace counters for the video features blog2video only limits account-wide (video_limits.py)."""
+
+    __tablename__ = "usage_counters"
+
+    workspace_id: Mapped[uuid.UUID] = mapped_column(Uuid, ForeignKey("workspaces.id", ondelete="CASCADE"),
+                                                    primary_key=True)
+    period: Mapped[str] = mapped_column(String(10), primary_key=True)  # 2026-10 | 2026-10-02 | all
+    metric: Mapped[str] = mapped_column(String(30), primary_key=True)
+    used: Mapped[int] = mapped_column(Integer, default=0)
+
+
 class Job(IdMixin, TimestampMixin, Base):
     """Covers ingest, tts and render jobs. kind decides which fields matter.
 

backend/app/models/user.py

@@ -2,7 +2,20 @@ import enum
 import uuid
 from datetime import datetime
 
-from sqlalchemy import JSON, Boolean, DateTime, Enum, ForeignKey, Integer, String, UniqueConstraint, Uuid
+from sqlalchemy import (
+    JSON,
+    Boolean,
+    DateTime,
+    Enum,
+    Float,
+    ForeignKey,
+    Integer,
+    String,
+    UniqueConstraint,
+    Uuid,
+    false,
+    true,
+)
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from app.db import Base
@@ -64,12 +77,45 @@ class Subscription(IdMixin, TimestampMixin, Base):
     workspace_id: Mapped[uuid.UUID] = mapped_column(
         Uuid, ForeignKey("workspaces.id", ondelete="CASCADE"), unique=True
     )
-    plan: Mapped[str] = mapped_column(String(20), default="free")  # free | writer | studio
+    # A row of the plans table. Only kept while status is active/trialing/past_due (see plans.effective_plan).
+    plan: Mapped[str] = mapped_column(String(20), ForeignKey("plans.id", onupdate="CASCADE"), default="free")
     status: Mapped[str] = mapped_column(String(20), default="active")
     provider: Mapped[str | None] = mapped_column(String(20))
     provider_customer_id: Mapped[str | None] = mapped_column(String(100))
     provider_subscription_id: Mapped[str | None] = mapped_column(String(100))
     current_period_end: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
+    # Video allowance, enforced by us (see app/services/video_quota.py): +1 per video before we call blog2video,
+    # -1 when it fails; video_plan/video_limit follow the effective plan and videos_used resets each period.
+    video_plan: Mapped[str] = mapped_column(String(20), default="free", server_default="free")
+    videos_used: Mapped[int] = mapped_column(Integer, default=0, server_default="0")
+    video_limit: Mapped[int] = mapped_column(Integer, default=0, server_default="0")
+    videos_period_start: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
+
+
+class PlanRecord(TimestampMixin, Base):
+    """One row per plan: limits, price and pricing-page copy. Edit a row to change a plan without a deploy
+    (app/services/plans.py reloads within a minute). Ids are fixed: Stripe prices and subscriptions use them."""
+
+    __tablename__ = "plans"
+
+    id: Mapped[str] = mapped_column(String(20), primary_key=True)  # free | writer | studio
+    sort_order: Mapped[int] = mapped_column(Integer, default=0)  # cheapest first; upgrades go up this order
+    name: Mapped[str] = mapped_column(String(50))
+    tagline: Mapped[str] = mapped_column(String(200), default="")
+    price_monthly_usd: Mapped[float] = mapped_column(Float, default=0)
+    sources: Mapped[int] = mapped_column(Integer, default=1)
+    indexed_posts: Mapped[int] = mapped_column(Integer, default=5)
+    audio_minutes: Mapped[int] = mapped_column(Integer, default=0)
+    videos: Mapped[int] = mapped_column(Integer, default=0)
+    launch_kits: Mapped[int] = mapped_column(Integer, default=0)  # -1 = unlimited
+    voice_cloning: Mapped[bool] = mapped_column(Boolean, default=False)
+    brand_kit: Mapped[bool] = mapped_column(Boolean, default=False)
+    features: Mapped[list] = mapped_column(JSON, default=list)  # bullet points on the pricing page
+    # Server defaults: 0006 seeds this table without these columns on a database 0001 built from the models.
+    video_premium: Mapped[bool] = mapped_column(Boolean, default=False, server_default=false())  # premium options
+    # False: `videos` is a lifetime total that never refills (Free). True: per month.
+    videos_monthly: Mapped[bool] = mapped_column(Boolean, default=True, server_default=true())
+    video_limits: Mapped[dict | None] = mapped_column(JSON, default=dict)  # see plans.VIDEO_LIMITS
 
 
 class BillingEvent(Base):

backend/app/pipeline/media.py

@@ -1,4 +1,4 @@
-"""Audio overviews (two hosts, ElevenLabs), videos and stills (Remotion renderer)."""
+"""Audio overviews (two hosts, ElevenLabs), audiograms and stills (Remotion renderer)."""
 
 import uuid
 
@@ -8,7 +8,7 @@ from sqlalchemy.orm import Session
 from app.config import settings
 from app.corpus import Corpus
 from app.llm import run
-from app.llm.signatures import PickQuotes, PodcastScript, VideoStoryboard
+from app.llm.signatures import PickQuotes, PodcastScript
 from app.models import Artifact, Document, Job, Source, User, VoiceProfile, Workspace
 from app.pipeline.generate import NothingToDo
 from app.pipeline.passages import notebook_docs, passages_for, tools_for, verify_refs
@@ -17,12 +17,6 @@ from app.services.jobs import record_usage, update_job
 from app.services.renderer import PermanentJobError, brand_props, request_render
 from app.services.storage import keys, storage
 
-SCENE_TYPES = {"title", "section", "pull_quote", "number", "outro"}
-VIDEO_STYLES = {
-    "short": ("ShortVertical", "9:16"),
-    "explainer": ("ExplainerLong", "16:9"),
-}
-
 
 def artifact_docs(db: Session, artifact: Artifact) -> list[Document]:
     if artifact.document_id:
@@ -112,91 +106,13 @@ def audio_overview(db: Session, job: Job, artifact: Artifact) -> dict:
     return {"artifact_id": str(artifact.id), "duration_s": round(t, 1)}
 
 
-# Video
-
-
-def _clamp(value, lo: float, hi: float) -> float:
-    try:
-        return max(lo, min(hi, float(value)))
-    except (TypeError, ValueError):
-        return lo
+# Video: blog2video makes videos now (app/routers/videos.py). The renderer still makes audiograms.
 
 
 def make_video(db: Session, job: Job, artifact: Artifact) -> None:
-    style = job.params.get("style", "short")
-    if style == "audiogram":
+    if job.params.get("style") == "audiogram":
         return make_audiogram(db, job, artifact)
-    composition, aspect = VIDEO_STYLES[style]
-    docs = artifact_docs(db, artifact)
-    if not docs:
-        raise NothingToDo("Add posts before making a video.")
-    corpus = Corpus(artifact.workspace_id)
-    workspace = db.get(Workspace, artifact.workspace_id)
-    update_job(db, job, progress=0.05, message="Storyboarding")
-    passages = passages_for(corpus, docs, budget_chars=60_000)
-    out = run.predict(VideoStoryboard, db=db, workspace_id=artifact.workspace_id, job=job,
-                      passages=passages, aspect=aspect)
-    scenes = [s for s in (out.get("scenes") or []) if (s.get("on_screen_text") or "").strip()]
-    if not scenes:
-        raise RuntimeError("The storyboard came back empty")
-    max_scenes = 8 if style == "short" else 14
-    scenes = scenes[:max_scenes]
-
-    captions: list[dict] = []
-    audio = bytearray()
-    cursor = 0.0
-    voice_a, _ = host_voices(db, artifact.workspace_id)
-    narrator = host_settings(db, artifact.workspace_id)["host_a"]
-    out_scenes = []
-    for i, s in enumerate(scenes):
-        narration = (s.get("narration") or "").strip()
-        duration = _clamp(s.get("duration_hint_s"), 2.0, 20.0)
-        if narration and settings.elevenlabs_api_key:
-            update_job(db, job, progress=0.15 + 0.5 * i / len(scenes), message=f"Narrating scene {i + 1}")
-            clip, words = tts.synthesize_with_timestamps(artifact.workspace_id, narration, voice_a, narrator)
-            seconds = tts.mp3_seconds(clip)
-            # Pad with silence so each clip starts exactly when its scene does.
-            audio += _silence(cursor - tts.mp3_seconds(bytes(audio)))
-            offset = int(cursor * 1000)
-            captions += [{**w, "startMs": w["startMs"] + offset, "endMs": w["endMs"] + offset} for w in words]
-            audio += clip
-            duration = max(duration, seconds + 0.3)
-        cursor += duration
-        scene_type = s.get("type") if s.get("type") in SCENE_TYPES else "section"
-        out_scenes.append({"type": scene_type, "onScreenText": s["on_screen_text"][:300],
-                           "narration": narration, "durationS": round(_clamp(duration, 0.5, 60), 2)})
-
-    props: dict = {"scenes": out_scenes, "captions": captions, "brand": brand_props(workspace)}
-    title = docs[0].title if len(docs) == 1 else (artifact.content_json or {}).get("title", "Notestack")
-    if composition == "ShortVertical":
-        hook = next((sc["onScreenText"] for sc in out_scenes if sc["type"] == "title"), title)
-        props["hook"] = hook[:120]
-    else:
-        props["title"] = title[:140]
-    if audio:
-        key = keys.artifact(artifact.workspace_id, artifact.id, "narration", "mp3")
-        storage.put_bytes(key, bytes(audio), "audio/mpeg")
-        props["audioUrl"] = storage.presign_get(key, ttl=6 * 3600)
-    artifact.content_json = {**(artifact.content_json or {}), "style": style, "composition": composition,
-                             "scenes": out_scenes, "duration_s": round(cursor, 1)}
-    artifact.status = "rendering"
-    db.commit()
-    update_job(db, job, progress=0.7, message="Handing off to the renderer")
-    request_render(job, artifact, composition, props)
-    record_usage(db, workspace_id=artifact.workspace_id, kind="video", provider="remotion",
-                 quantity=round(cursor, 1), unit="seconds", job=job)
-
-
-_SILENT_FRAME = None
-
-
-def _silence(seconds: float) -> bytes:
-    """MPEG1 Layer III 128 kbps 44.1 kHz silent frames (417 bytes, ~26 ms each)."""
-    global _SILENT_FRAME
-    if _SILENT_FRAME is None:
-        _SILENT_FRAME = bytes([0xFF, 0xFB, 0x90, 0x64]) + bytes(413)
-    frames = int(seconds / 0.026122)
-    return _SILENT_FRAME * max(frames, 0)
+    raise PermanentJobError("Videos are now made in the Videos editor.")
 
 
 def make_audiogram(db: Session, job: Job, artifact: Artifact) -> None:
@@ -217,7 +133,7 @@ def make_audiogram(db: Session, job: Job, artifact: Artifact) -> None:
     db.commit()
     update_job(db, job, progress=0.1, message="Handing off to the renderer")
     request_render(job, artifact, "AudiogramSquare", props)
-    record_usage(db, workspace_id=artifact.workspace_id, kind="video", provider="remotion",
+    record_usage(db, workspace_id=artifact.workspace_id, kind="render", provider="remotion",
                  quantity=props["durationS"], unit="seconds", job=job)
 
 

backend/app/routers/artifacts.py

@@ -21,7 +21,7 @@ ArtifactType = Literal["summary", "audio_overview", "video", "quote_card", "caro
 
 
 class RenderIn(BaseModel):
-    composition: Literal["ShortVertical", "ExplainerLong", "AudiogramSquare", "QuoteCard", "CarouselSlide"]
+    composition: Literal["AudiogramSquare", "QuoteCard", "CarouselSlide"]
     props: dict
 
 
@@ -33,8 +33,8 @@ class GenerateIn(BaseModel):
     # audio_overview
     format: Literal["deep_dive", "brief", "debate"] = "deep_dive"
     minutes: int = Field(6, ge=1, le=30)
-    # video
-    style: Literal["short", "explainer", "audiogram"] = "short"
+    # video: only audiograms here; other videos are made by blog2video (/api/videos)
+    style: str = "audiogram"
     audio_artifact_id: uuid.UUID | None = None
     # carousel
     slides: list[dict] | None = None
@@ -81,12 +81,12 @@ def generate(body: GenerateIn, ctx: Ctx = Depends(get_ctx)):
         body.notebook_id = ensure_archive_notebook(ctx).id
     params: dict = {}
     content: dict = {}
-    if body.type == "video" and body.style == "audiogram":
+    if body.type == "video" and body.style != "audiogram":
+        raise HTTPException(410, "Videos moved to /app/videos")
+    if body.type == "video":
         if not body.audio_artifact_id:
             raise HTTPException(400, "Pick an audio overview for the audiogram")
         source = get_artifact_or_404(ctx, body.audio_artifact_id)
-        seconds = float((source.content_json or {}).get("duration_s", 60))
-        check_limit(ctx.db, ctx.workspace, "video_minutes", seconds / 60)
         title = f"Audiogram: {(source.content_json or {}).get('title', 'Audio overview')}"
         params = {"style": "audiogram", "audio_artifact_id": str(source.id)}
         artifact, job = start_artifact(ctx.db, ctx.workspace.id, "video", title=title, notebook_id=source.notebook_id,
@@ -101,10 +101,6 @@ def generate(body: GenerateIn, ctx: Ctx = Depends(get_ctx)):
         check_limit(ctx.db, ctx.workspace, "audio_minutes", body.minutes)
         params = {"format": body.format, "minutes": body.minutes}
         title = f"Audio overview: {target}"
-    elif body.type == "video":
-        check_limit(ctx.db, ctx.workspace, "video_minutes", 1 if body.style == "short" else 3)
-        params = {"style": body.style}
-        title = f"{'Short' if body.style == 'short' else 'Explainer'} video: {target}"
     elif body.type == "launch_kit":
         if not body.document_id:
             raise HTTPException(400, "A Launch Kit is made from one post")
@@ -174,6 +170,11 @@ def patch_artifact(artifact_id: uuid.UUID, body: PatchIn, ctx: Ctx = Depends(get
 @router.delete("/{artifact_id}")
 def delete_artifact(artifact_id: uuid.UUID, ctx: Ctx = Depends(get_ctx)):
     a = get_artifact_or_404(ctx, artifact_id)
+    if a.type == "video" and (a.content_json or {}).get("provider") == "blog2video":
+        from app.routers.videos import remove_video  # also removes it from blog2video
+
+        remove_video(ctx, a)
+        return {"ok": True}
     storage.delete_prefix(f"ws/{ctx.workspace.id}/artifacts/{a.id}/")
     ctx.db.query(CalendarItem).filter(CalendarItem.artifact_id == a.id, CalendarItem.status == "scheduled").delete()
     ctx.db.delete(a)

backend/app/routers/billing.py

@@ -8,7 +8,7 @@ from app.auth import Ctx, get_ctx
 from app.config import settings
 from app.db import get_db
 from app.services.billing import billing_status, create_checkout_url, create_portal_url
-from app.services.plans import PLAN_ORDER, PLANS, effective_plan, plan_dict
+from app.services.plans import PLANS, effective_plan, plan_dict, plan_order
 
 router = APIRouter(prefix="/api/billing", tags=["billing"])
 
@@ -40,7 +40,8 @@ def checkout(body: CheckoutIn, ctx: Ctx = Depends(get_ctx)):
     if not settings.billing_enabled:
         raise HTTPException(409, {"code": "billing_disabled", "message": "Checkout is not available yet."})
     current = effective_plan(ctx.db, ctx.workspace)
-    if PLAN_ORDER.index(body.plan) <= PLAN_ORDER.index(current.id):
+    order = plan_order()
+    if body.plan not in PLANS or order.index(body.plan) <= order.index(current.id):
         raise HTTPException(409, {"code": "already_on_plan", "message": f"You are already on {current.name}."})
     return {"url": create_checkout_url(ctx.db, ctx.user, ctx.workspace, PLANS[body.plan], body.cycle)}
 

backend/app/routers/notebooks.py

@@ -7,6 +7,7 @@ from fastapi import APIRouter, Depends, HTTPException
 from fastapi.responses import StreamingResponse
 from pydantic import BaseModel, Field
 from sqlalchemy import delete, func, select
+from sqlalchemy.exc import IntegrityError
 
 from app.auth import Ctx, get_ctx
 from app.config import settings
@@ -77,12 +78,20 @@ ARCHIVE_TITLE = "All posts"
 
 def ensure_archive_notebook(ctx: Ctx) -> Notebook:
     """The workspace's "All posts" notebook, topped up with every indexed post (locked posts are skipped)."""
-    nb = ctx.db.scalar(select(Notebook).where(Notebook.workspace_id == ctx.workspace.id, Notebook.is_archive.is_(True)))
+    def find() -> Notebook | None:
+        return ctx.db.scalar(select(Notebook).where(Notebook.workspace_id == ctx.workspace.id,
+                                                    Notebook.is_archive.is_(True)))
+
+    nb = find()
     if not nb:
-        nb = Notebook(workspace_id=ctx.workspace.id, title=ARCHIVE_TITLE, is_archive=True,
-                      description="Every indexed post in your archive, kept up to date.")
-        ctx.db.add(nb)
-        ctx.db.flush()
+        try:
+            nb = Notebook(workspace_id=ctx.workspace.id, title=ARCHIVE_TITLE, is_archive=True,
+                          description="Every indexed post in your archive, kept up to date.")
+            ctx.db.add(nb)
+            ctx.db.flush()
+        except IntegrityError:  # a concurrent request made it first (uq_notebooks_one_archive)
+            ctx.db.rollback()
+            nb = find()
     ids = list(ctx.db.scalars(select(Document.id).where(Document.workspace_id == ctx.workspace.id)))
     _add_docs(ctx, nb, ids)
     ctx.db.commit()

backend/app/routers/video_edit.py

@@ -0,0 +1,212 @@
+"""The video editor: one allowlisted proxy onto blog2video's /api/projects/{id}/... endpoints.
+
+    <METHOD> /api/videos/{artifact_id}/p/<path>  ->  <METHOD> /api/projects/{blog2video id}/<path>
+
+Only paths in RULES pass (anything else is 404). Before forwarding, the video must be this workspace's
+(b2v_access.video_or_404), every template / voice / style id in a JSON body must be this workspace's (check_refs),
+premium (★) features need a paid plan, and AI edits come out of the workspace's own counter (given back if
+blog2video refuses). A template switch also uses one video, as it does on blog2video.
+
+JSON bodies, multipart uploads (images, voiceovers, portraits) and binary answers (downloads, stills) pass through.
+"""
+
+import json
+import re
+import uuid
+from dataclasses import dataclass
+
+from fastapi import APIRouter, Depends, HTTPException, Request, Response
+from starlette.concurrency import run_in_threadpool
+from starlette.datastructures import UploadFile
+
+from app.auth import Ctx, get_ctx
+from app.routers.videos import b2v_ready, store, upstream
+from app.services import b2v_access, video_limits, video_quota
+from app.services import blog2video as b2v
+from app.services.plans import effective_plan, plan_limit_error
+
+router = APIRouter(prefix="/api/videos", tags=["videos"])
+
+MAX_JSON_BYTES = 512 * 1024
+MAX_FILE_BYTES = 50 * 1024 * 1024
+S = r"\d+"  # a scene id
+
+
+@dataclass(frozen=True)
+class Rule:
+    ai_edits: int = 0  # AI edits this call uses (per workspace, video_limits "ai_edits")
+    per_scene: bool = False  # ai_edits is per scene_ids entry (avatar batches)
+    premium: str | None = None  # ★: what to call it in the upgrade message
+    uses_video: bool = False  # a template switch: one video from the allowance
+    raw: bool = False  # binary answer (download, still)
+    timeout: float = 30
+    status: str | None = None  # artifact status to show once it started
+
+
+RULES: list[tuple[str, re.Pattern, Rule]] = [(m, re.compile(f"^{p}$"), r) for m, p, r in [
+    # Project settings, logo, assets
+    ("GET", "", Rule(timeout=60)),  # the whole project: slow on a far-away database
+    ("PATCH", "update-project", Rule()),
+    ("PATCH", "", Rule()),
+    ("POST", "logo", Rule()),
+    ("DELETE", "logo", Rule()),
+    ("PATCH", rf"assets/{S}/exclude", Rule()),
+    ("DELETE", rf"assets/{S}", Rule()),
+    ("GET", "layouts", Rule()),
+    ("GET", "status", Rule()),
+    # Scenes
+    ("PUT", rf"scenes/{S}", Rule()),
+    ("DELETE", rf"scenes/{S}", Rule()),
+    ("PUT", "bulk-update-scenes", Rule()),
+    ("POST", "scenes/reorder", Rule()),
+    ("POST", rf"scenes/{S}/regenerate", Rule(ai_edits=1, timeout=120)),
+    ("POST", "scenes/add", Rule(ai_edits=1)),
+    ("GET", "scenes/add-status", Rule()),
+    # Images
+    ("POST", rf"scenes/{S}/image", Rule(timeout=60)),
+    ("POST", rf"scenes/{S}/generate-image", Rule(ai_edits=1, timeout=120)),
+    ("PATCH", rf"scenes/{S}/image-focus", Rule()),
+    ("POST", "images/move", Rule()),
+    ("POST", "images/swap", Rule()),
+    ("POST", "images/duplicate", Rule()),
+    ("POST", "images/assign-existing", Rule()),
+    # Stock footage
+    ("GET", "stock-footage/search", Rule()),
+    ("POST", rf"scenes/{S}/stock-footage", Rule(ai_edits=1, timeout=60)),
+    ("GET", "stock-footage/pending", Rule()),
+    ("POST", "stock-footage/link", Rule()),
+    ("POST", "stock-footage/approve", Rule(status="generating")),
+    ("POST", "stock-footage/reject", Rule(status="generating")),
+    # Voice, voiceovers, language, template
+    ("POST", rf"scenes/{S}/voiceover", Rule(timeout=60)),
+    # blog2video keeps the project's status during a voiceover delete; marking ours lets a reload resume its progress
+    # (voice-change-status reports it, kind "delete"), and the next status check sets it back.
+    ("POST", "delete-voiceover", Rule(status="voice_regenerating")),
+    ("POST", "change-voice", Rule(status="voice_regenerating")),
+    ("GET", "voice-change-status", Rule()),
+    ("POST", "change-language", Rule(status="language_regenerating")),
+    ("GET", "language-change-status", Rule()),
+    ("POST", "change-template-regenerate-layouts", Rule(uses_video=True, status="regenerating")),
+    ("GET", "template-change-status", Rule()),
+    # Refresh the script
+    ("POST", "regenerate-script", Rule(status="script_regenerating")),
+    ("GET", "regenerate-script-status", Rule()),
+    ("GET", "regenerate-script/preview", Rule()),
+    ("POST", "regenerate-script/verify", Rule()),
+    ("POST", "regenerate-script/regenerate", Rule()),
+    # AI chat editing ★
+    ("POST", "chat", Rule(ai_edits=1, premium="AI chat editing", timeout=120)),
+    ("GET", "chat/history", Rule(premium="AI chat editing")),
+    # Avatars ★ (blog2video charges the whole batch at authorize: 10 AI edits per scene)
+    ("POST", "avatar-batch/authorize", Rule(ai_edits=10, per_scene=True, premium="Avatars")),
+    ("POST", rf"scenes/{S}/avatar", Rule(premium="Avatars")),
+    ("GET", rf"scenes/{S}/avatar-status", Rule()),
+    ("DELETE", rf"scenes/{S}/avatar", Rule()),
+    ("POST", rf"scenes/{S}/avatar-matte", Rule(premium="Avatars")),
+    ("POST", "avatar-matte-all", Rule(premium="Avatars")),
+    ("POST", "avatar-retry-failed", Rule(premium="Avatars")),
+    ("GET", "avatar-progress", Rule()),
+    ("POST", "avatar-portrait", Rule(premium="Avatars", timeout=60)),
+    ("DELETE", "avatar-portrait", Rule()),
+    ("PATCH", rf"scenes/{S}/avatar-focus", Rule()),
+    ("PATCH", rf"scenes/{S}/avatar-appearance", Rule()),
+    # Render, download, frames
+    ("POST", "render", Rule(status="rendering")),
+    ("GET", "render-status", Rule()),
+    ("POST", "cancel-render", Rule()),
+    ("GET", "download-url", Rule()),
+    ("GET", "download", Rule(raw=True, timeout=120)),
+    ("GET", "download-studio", Rule(raw=True, premium="The Remotion source download", timeout=120)),
+    ("GET", "render-still", Rule(raw=True, timeout=60)),
+    ("POST", "render-stills", Rule(timeout=120)),
+]]
+
+
+def rule_for(method: str, path: str) -> Rule | None:
+    for m, pattern, rule in RULES:
+        if m == method and pattern.match(path):
+            return rule
+    return None
+
+
+async def _read_body(request: Request) -> tuple[dict | None, dict | None, list | None]:
+    """(json, form fields, files) from the browser's request."""
+    ctype = request.headers.get("content-type", "")
+    if ctype.startswith("multipart/form-data"):
+        form = await request.form()
+        data, files = {}, []
+        for key, value in form.multi_items():
+            if isinstance(value, UploadFile):
+                content = await value.read(MAX_FILE_BYTES + 1)
+                if len(content) > MAX_FILE_BYTES:
+                    raise HTTPException(413, "That file is too large.")
+                files.append((key, (value.filename or "file", content, value.content_type or
+                                    "application/octet-stream")))
+            else:
+                data[key] = value
+        return None, data, files
+    raw = await request.body()
+    if not raw:
+        return None, None, None
+    if len(raw) > MAX_JSON_BYTES:
+        raise HTTPException(413, "Request too large")
+    try:
+        return json.loads(raw), None, None
+    except ValueError:
+        raise HTTPException(400, "Send JSON") from None
+
+
+def _charge(ctx: Ctx, rule: Rule, body: dict | None, form: dict | None) -> int:
+    """Premium, references and counters, all before blog2video is called. Returns AI edits taken."""
+    plan = effective_plan(ctx.db, ctx.workspace)
+    if rule.premium:
+        video_limits.require_premium(ctx.db, ctx.workspace, rule.premium, plan)
+    refs = body if isinstance(body, dict) else (form or {})
+    with upstream():  # checking a template or voice may need blog2video's catalog
+        b2v_access.check_refs(ctx, refs, plan)
+    edits = rule.ai_edits
+    if rule.per_scene:
+        scenes = (body or {}).get("scene_ids") if isinstance(body, dict) else None
+        if not isinstance(scenes, list) or not scenes:
+            raise HTTPException(400, "Pick at least one scene")
+        edits *= len(scenes)
+    if edits:
+        video_limits.take(ctx.db, ctx.workspace, "ai_edits", edits, plan=plan)
+    if rule.uses_video and not video_quota.reserve(ctx.db, ctx.workspace.id):
+        if edits:
+            video_limits.give_back(ctx.db, ctx.workspace.id, "ai_edits", edits)
+        raise plan_limit_error(plan, "videos", "Switching the template uses a video, and you have none left.")
+    return edits
+
+
+@router.api_route("/{artifact_id}/p/{path:path}", methods=["GET", "POST", "PUT", "PATCH", "DELETE"])
+async def project_proxy(artifact_id: uuid.UUID, path: str, request: Request, ctx: Ctx = Depends(get_ctx),
+                        _: None = Depends(b2v_ready)):
+    path = path.strip("/")
+    rule = rule_for(request.method, path)
+    if rule is None:
+        raise HTTPException(404, "Not found")
+    a, vid, _row = b2v_access.video_or_404(ctx, artifact_id)
+    body, form, files = await _read_body(request)
+    edits = await run_in_threadpool(_charge, ctx, rule, body, form)
+    params = dict(request.query_params)
+
+    def call():
+        return b2v.project_call(request.method, vid, path, json=body, data=form, files=files or None,
+                                params=params or None, timeout=rule.timeout, raw=rule.raw)
+
+    try:
+        with upstream():
+            result = await run_in_threadpool(call)
+    except HTTPException:
+        if edits:
+            video_limits.give_back(ctx.db, ctx.workspace.id, "ai_edits", edits)
+        if rule.uses_video:
+            video_quota.unreserve(ctx.db, ctx.workspace.id)
+        raise
+    if rule.status:
+        store(ctx, a, status=rule.status)
+    if rule.raw:
+        content, ctype = result
+        return Response(content, media_type=ctype, headers={"Cache-Control": "no-store"})
+    return result

backend/app/routers/video_styles.py

@@ -0,0 +1,88 @@
+"""Custom video styles: writing guidance for the script, used on videos as custom:<id>.
+
+Styles are made on our one blog2video account, so b2v_styles records which workspace made each; only that
+workspace sees, uses, edits or deletes it. Built-in styles are read-only here, and "Your Style" (which learns from
+every workspace's edits) is never offered. The account-wide style selection, pin and built-in overrides are never
+touched (blog2video.DENIED).
+"""
+
+from typing import Literal
+
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel, Field
+
+from app.auth import Ctx, get_ctx
+from app.models import B2VStyle
+from app.routers.videos import b2v_ready, upstream
+from app.services import b2v_access
+from app.services import blog2video as b2v
+
+router = APIRouter(prefix="/api/video-styles", tags=["videos"])
+
+
+class DraftIn(BaseModel):
+    prompt: str = Field(min_length=20, max_length=1000)
+
+
+class StyleIn(BaseModel):
+    name: str = Field(min_length=1, max_length=80)
+    guidance: str = Field(min_length=1, max_length=2000)
+    creation_method: Literal["manual", "ai"] = "manual"
+    source_prompt: str | None = Field(None, max_length=1000)
+
+
+class StylePatchIn(BaseModel):
+    name: str = Field(min_length=1, max_length=80)
+    guidance: str = Field(min_length=1, max_length=2000)
+    version: int = Field(ge=0)
+
+
+@router.get("")
+def list_styles(ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    with upstream():
+        return b2v_access.visible_styles(ctx)
+
+
+@router.post("/ai-draft")
+def ai_draft(body: DraftIn, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    """A name and guidance written from a description; nothing is saved."""
+    with upstream():
+        return b2v.request("POST", "/api/video-styles/ai-draft", json=body.model_dump(), timeout=90)
+
+
+def _out(s: dict) -> dict:
+    return {"id": s.get("id"), "custom_id": s.get("custom_id"), "name": s.get("name"), "guidance": s.get("guidance"),
+            "description": s.get("description"), "version": s.get("version"), "kind": "custom"}
+
+
+@router.post("", status_code=201)
+def create_style(body: StyleIn, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    with upstream():
+        made = b2v.request("POST", "/api/video-styles/custom", json=body.model_dump())
+    ctx.db.add(B2VStyle(b2v_style_id=int(made["custom_id"]), workspace_id=ctx.workspace.id, name=body.name))
+    ctx.db.commit()
+    return _out(made)
+
+
+@router.patch("/{style_id}")
+def update_style(style_id: int, body: StylePatchIn, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    row = b2v_access.owned_style(ctx, style_id)
+    with upstream():
+        made = b2v.request("PATCH", f"/api/video-styles/custom/{style_id}", json=body.model_dump())
+    row.name = body.name
+    ctx.db.commit()
+    return _out(made)
+
+
+@router.delete("/{style_id}")
+def delete_style(style_id: int, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    row = b2v_access.owned_style(ctx, style_id)
+    try:
+        with upstream():
+            b2v.request("DELETE", f"/api/video-styles/custom/{style_id}")
+    except HTTPException as e:
+        if e.status_code != 404:
+            raise
+    ctx.db.delete(row)
+    ctx.db.commit()
+    return {"ok": True}

backend/app/routers/video_templates.py

@@ -0,0 +1,277 @@
+"""Custom video templates: made from a website, a document or a description, then generated and edited.
+
+Templates are made on our one blog2video account, which has a small lifetime number of template slots (a delete
+does not give one back). b2v_templates records which workspace made each template; only that workspace sees, uses,
+edits or deletes it, and each workspace has its own share of slots and daily AI steps (video_limits).
+
+Create: extract a theme (/extract/url | /extract/doc | /extract/prompt) -> POST "" (uses a slot) -> /{id}/generate
+-> poll /{id}/generation-status until complete (the template becomes usable in the wizard) or error.
+Edit: /{id}/p/<path> -> /api/custom-templates/{id}/<path>, allowlisted in RULES.
+"""
+
+import json
+import re
+from dataclasses import dataclass
+
+from fastapi import APIRouter, Depends, File, Form, HTTPException, Request, Response, UploadFile
+from pydantic import BaseModel, Field
+from sqlalchemy import select
+from starlette.concurrency import run_in_threadpool
+from starlette.datastructures import UploadFile as StarletteUpload
+
+from app.auth import Ctx, get_ctx
+from app.models import B2VTemplate, B2VVideo
+from app.routers.videos import b2v_ready, upstream
+from app.services import b2v_access, video_limits
+from app.services import blog2video as b2v
+from app.services.plans import effective_plan, plan_limit_error
+
+router = APIRouter(prefix="/api/video-templates", tags=["videos"])
+
+DOC_MAX_BYTES = 10 * 1024 * 1024
+LOGO_MAX_BYTES = 2 * 1024 * 1024
+AI_TIMEOUT = 120
+
+
+def _out(t: B2VTemplate) -> dict:
+    return {"id": t.b2v_template_id, "ref": f"custom_{t.b2v_template_id}", "name": t.name, "ready": t.ready,
+            "created_at": t.created_at.isoformat() if t.created_at else None}
+
+
+def _can_make(ctx: Ctx) -> None:
+    """Refuse early (before any AI work) when the workspace has no template slots left."""
+    plan = effective_plan(ctx.db, ctx.workspace)
+    limit = int(plan.video_limits.get("templates", 0))
+    if limit >= 0 and video_limits.used(ctx.db, ctx.workspace.id, "templates") >= limit:
+        raise plan_limit_error(plan, "video_limits.templates",
+                               "Your plan does not include custom templates." if limit == 0
+                               else f"You have made all {limit} custom templates your plan includes.")
+
+
+def _counted(ctx: Ctx, metric: str, call):
+    video_limits.take(ctx.db, ctx.workspace, metric)
+    try:
+        with upstream():
+            return call()
+    except HTTPException:
+        video_limits.give_back(ctx.db, ctx.workspace.id, metric)
+        raise
+
+
+@router.get("")
+def list_templates(ctx: Ctx = Depends(get_ctx)):
+    limits = video_limits.report(ctx.db, ctx.workspace)["limits"]
+    return {"templates": [_out(t) for t in b2v_access.my_templates(ctx)],
+            "limits": {k: limits[k] for k in ("templates", "template_ai_daily")}}
+
+
+# 1. Extract a theme
+
+
+class ExtractUrlIn(BaseModel):
+    url: str = Field(min_length=1, max_length=2048)
+
+
+class ExtractPromptIn(BaseModel):
+    prompt: str = Field(min_length=15, max_length=5000)
+    name: str | None = Field(None, max_length=255)
+
+
+@router.post("/extract/url")
+def extract_from_url(body: ExtractUrlIn, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    if not re.match(r"https?://", body.url):
+        raise HTTPException(400, "Enter a link that starts with http:// or https://")
+    _can_make(ctx)
+    with upstream():
+        return b2v.request("POST", "/api/custom-templates/extract-theme", json=body.model_dump(), timeout=AI_TIMEOUT)
+
+
+@router.post("/extract/prompt")
+def extract_from_prompt(body: ExtractPromptIn, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    _can_make(ctx)
+    return _counted(ctx, "template_ai_daily", lambda: b2v.request(
+        "POST", "/api/custom-templates/extract-theme-from-prompt", json=body.model_dump(), timeout=AI_TIMEOUT))
+
+
+@router.post("/extract/doc")
+async def extract_from_doc(file: UploadFile = File(...), name: str = Form(""), ctx: Ctx = Depends(get_ctx),
+                           _: None = Depends(b2v_ready)):
+    data = await file.read(DOC_MAX_BYTES + 1)
+    if len(data) > DOC_MAX_BYTES:
+        raise HTTPException(400, "Keep the document under 10 MB.")
+    _can_make(ctx)
+    files = {"file": (file.filename or "brand.pdf", data, file.content_type or "application/octet-stream")}
+    return await run_in_threadpool(_counted, ctx, "template_ai_daily", lambda: b2v.request(
+        "POST", "/api/custom-templates/extract-theme-from-doc", data={"name": name[:255]}, files=files,
+        timeout=AI_TIMEOUT))
+
+
+# 2. Create (uses a slot) and 3. generate
+
+
+class CreateIn(BaseModel):
+    name: str = Field(min_length=1, max_length=255)
+    theme: dict
+    source_url: str | None = Field(None, max_length=2048)
+    logo_urls: list[str] | None = Field(None, max_length=20)
+    og_image: str | None = Field(None, max_length=2048)
+    screenshot_url: str | None = Field(None, max_length=2048)
+    reason: str | None = Field(None, max_length=2000)
+
+
+@router.post("", status_code=201)
+def create_template(body: CreateIn, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    made = _counted(ctx, "templates", lambda: b2v.request("POST", "/api/custom-templates",
+                                                          json=body.model_dump(exclude_none=True), timeout=60))
+    row = B2VTemplate(b2v_template_id=int(made["id"]), workspace_id=ctx.workspace.id, name=body.name[:255])
+    ctx.db.add(row)
+    ctx.db.commit()
+    return _out(row)
+
+
+@router.post("/{template_id}/generate")
+def generate(template_id: int, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    b2v_access.owned_template(ctx, template_id)
+    return _counted(ctx, "template_ai_daily", lambda: b2v.request(
+        "POST", f"/api/custom-templates/{template_id}/generate-code", timeout=60))
+
+
+@router.get("/{template_id}/generation-status")
+def generation_status(template_id: int, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    row = b2v_access.owned_template(ctx, template_id)
+    with upstream():
+        s = b2v.request("GET", f"/api/custom-templates/{template_id}/generation-status") or {}
+    ready = s.get("status") == "complete"
+    if ready != row.ready:
+        row.ready = ready
+        ctx.db.commit()
+    return {**s, "ready": ready}
+
+
+@router.delete("/{template_id}")
+def delete_template(template_id: int, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    """blog2video refuses (template_in_use) while any video on the account uses the template. We force it only
+    when every such video is this workspace's: another workspace's video must never lose its template."""
+    row = b2v_access.owned_template(ctx, template_id)
+    ref = f"custom_{template_id}"
+    try:
+        with upstream():
+            b2v.request("DELETE", f"/api/custom-templates/{template_id}")
+    except HTTPException as e:
+        if e.status_code == 404:
+            pass
+        elif e.status_code == 409:
+            others = ctx.db.scalar(select(B2VVideo.id).where(B2VVideo.template_ref == ref,
+                                                             B2VVideo.workspace_id != ctx.workspace.id).limit(1))
+            if others is not None:
+                raise HTTPException(409, "This template is in use and can not be deleted.") from None
+            with upstream():
+                b2v.request("DELETE", f"/api/custom-templates/{template_id}", params={"force": "true"})
+        else:
+            raise
+    ctx.db.delete(row)
+    ctx.db.commit()
+    return {"ok": True}  # the slot is not given back: blog2video's slots are lifetime
+
+
+# Editing: allowlisted proxy
+
+
+@dataclass(frozen=True)
+class Rule:
+    ai_edit: bool = False  # ★ one AI edit
+    metric: str | None = None  # another counter this uses (a lifetime slot, a daily AI step)
+    raw: bool = False
+
+
+K = r"(intro|outro|content_\d+)"  # scene keys
+RULES: list[tuple[str, re.Pattern, Rule]] = [(m, re.compile(f"^{p}$"), r) for m, p, r in [
+    ("GET", "", Rule()),
+    ("PUT", "", Rule()),
+    ("GET", "code", Rule()),
+    ("POST", "upload-logo", Rule()),
+    ("POST", f"scenes/{K}/ai-edit", Rule(ai_edit=True)),
+    ("GET", f"scenes/{K}/ai-edit/status", Rule()),
+    ("GET", "scene-drafts", Rule()),
+    ("GET", f"scenes/{K}/draft", Rule()),
+    ("POST", f"scenes/{K}/draft/apply", Rule()),
+    ("POST", f"scenes/{K}/draft/discard", Rule()),
+    ("PATCH", f"scenes/{K}/chart", Rule()),
+    ("PATCH", f"scenes/{K}/font-defaults", Rule()),
+    ("PATCH", "scenes/font-defaults", Rule()),
+    ("GET", "versions", Rule()),
+    ("POST", r"versions/\d+/rollback", Rule()),
+    ("POST", "regenerate-code", Rule(metric="templates")),  # uses a slot, like creating one
+    ("POST", "resume-generation", Rule()),
+    ("POST", "rating", Rule()),
+]]
+
+
+def _rule(method: str, path: str) -> Rule | None:
+    return next((r for m, p, r in RULES if m == method and p.match(path)), None)
+
+
+def _take(ctx: Ctx, rule: Rule) -> list[str]:
+    taken: list[str] = []
+    try:
+        if rule.ai_edit:
+            plan = video_limits.require_premium(ctx.db, ctx.workspace, "AI template editing")
+            video_limits.take(ctx.db, ctx.workspace, "ai_edits", plan=plan)
+            taken.append("ai_edits")
+        if rule.metric:
+            video_limits.take(ctx.db, ctx.workspace, rule.metric)
+            taken.append(rule.metric)
+    except HTTPException:
+        for metric in taken:
+            video_limits.give_back(ctx.db, ctx.workspace.id, metric)
+        raise
+    return taken
+
+
+@router.api_route("/{template_id}/p/{path:path}", methods=["GET", "POST", "PUT", "PATCH"])
+async def template_proxy(template_id: int, path: str, request: Request, ctx: Ctx = Depends(get_ctx),
+                         _: None = Depends(b2v_ready)):
+    path = path.strip("/")
+    rule = _rule(request.method, path)
+    if rule is None:
+        raise HTTPException(404, "Not found")
+    row = b2v_access.owned_template(ctx, template_id)
+    body = form = files = None
+    if request.headers.get("content-type", "").startswith("multipart/form-data"):
+        parsed = await request.form()
+        form, files = {}, []
+        for key, value in parsed.multi_items():
+            if isinstance(value, StarletteUpload):
+                content = await value.read(LOGO_MAX_BYTES + 1)
+                if len(content) > LOGO_MAX_BYTES:
+                    raise HTTPException(413, "Keep the file under 2 MB.")
+                files.append((key, (value.filename or "logo.png", content, value.content_type or "image/png")))
+            else:
+                form[key] = value
+    elif raw := await request.body():
+        try:
+            body = json.loads(raw)
+        except ValueError:
+            raise HTTPException(400, "Send JSON") from None
+    taken = await run_in_threadpool(_take, ctx, rule)
+
+    def call():
+        return b2v.request(request.method, f"/api/custom-templates/{template_id}/{path}".rstrip("/"), json=body,
+                           data=form, files=files or None, params=dict(request.query_params) or None,
+                           timeout=AI_TIMEOUT, raw=rule.raw)
+
+    try:
+        with upstream():
+            result = await run_in_threadpool(call)
+    except HTTPException:
+        for metric in taken:
+            video_limits.give_back(ctx.db, ctx.workspace.id, metric)
+        raise
+    if request.method == "PUT" and path == "" and isinstance(body, dict) and body.get("name"):
+        row.name = str(body["name"])[:255]
+        ctx.db.commit()
+    if rule.raw:
+        content, ctype = result
+        return Response(content, media_type=ctype)
+    return result
+

backend/app/routers/video_voices.py

@@ -0,0 +1,267 @@
+"""Voices for videos: the workspace's saved voices, the built-in library, and custom voices (design, clone).
+
+"My voices" (user_saved_voices) lives only here: blog2video's saved-voice list is one list for the whole account.
+Custom voices are made on our blog2video account, so b2v_custom_voices records which workspace made each one;
+only that workspace can use, play or delete it. Designing, keeping, cloning and samples are premium (★) and come out
+of the workspace's own daily and total counters (video_limits).
+"""
+
+import logging
+from typing import Literal
+
+from fastapi import APIRouter, Depends, File, Form, HTTPException, Response, UploadFile
+from pydantic import BaseModel, Field
+from sqlalchemy import select
+
+from app.auth import Ctx, get_ctx
+from app.models import B2VCustomVoice, UserSavedVoice
+from app.routers.videos import b2v_ready, upstream
+from app.services import b2v_access, video_limits
+from app.services import blog2video as b2v
+
+log = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api/video-voices", tags=["videos"])
+
+CLONE_MAX_BYTES = 50 * 1024 * 1024
+STARTER_VOICES = 4  # a new workspace starts with this many free built-in voices saved
+
+
+def _labels(v: dict) -> dict:
+    return v.get("labels") or {}
+
+
+def _voice_out(v: UserSavedVoice) -> dict:
+    return {"voice_id": v.voice_id, "name": v.name, "preview_url": v.preview_url, "gender": v.gender,
+            "accent": v.accent, "premium": v.premium, "is_custom": v.is_custom}
+
+
+def _library_out(v: dict, saved: set[str]) -> dict:
+    labels = _labels(v)
+    return {"voice_id": v["voice_id"], "name": (v.get("name") or "Voice").split(" - ")[0].strip(),
+            "description": v.get("description") or labels.get("description") or "", "preview_url": v.get("preview_url"),
+            "gender": labels.get("gender"), "accent": labels.get("accent"), "age": labels.get("age"),
+            "premium": v.get("plan") == "paid", "saved": v["voice_id"] in saved}
+
+
+def _save_builtin(ctx: Ctx, v: dict) -> UserSavedVoice:
+    labels = _labels(v)
+    row = UserSavedVoice(workspace_id=ctx.workspace.id, voice_id=v["voice_id"],
+                         name=(v.get("name") or "Voice").split(" - ")[0].strip()[:255],
+                         preview_url=v.get("preview_url"),
+                         gender=labels.get("gender"), accent=labels.get("accent"), premium=v.get("plan") == "paid")
+    ctx.db.merge(row)
+    return row
+
+
+def _saved(ctx: Ctx) -> list[UserSavedVoice]:
+    return list(ctx.db.scalars(select(UserSavedVoice).where(UserSavedVoice.workspace_id == ctx.workspace.id)
+                               .order_by(UserSavedVoice.created_at)))
+
+
+@router.get("")
+def voices(ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    """My voices (for the wizard), the built-in library (to save from) and my custom voices."""
+    with upstream():
+        library = b2v.prebuilt_voices()
+    saved = _saved(ctx)
+    if not saved:
+        for v in [v for v in library if v.get("plan") != "paid" and v.get("voice_id")][:STARTER_VOICES]:
+            _save_builtin(ctx, v)
+        ctx.db.commit()
+        saved = _saved(ctx)
+    ids = {v.voice_id for v in saved}
+    custom = ctx.db.scalars(select(B2VCustomVoice).where(B2VCustomVoice.workspace_id == ctx.workspace.id)
+                            .order_by(B2VCustomVoice.created_at.desc()))
+    return {"saved": [_voice_out(v) for v in saved],
+            "library": [_library_out(v, ids) for v in library if v.get("voice_id")],
+            "custom": [{"id": c.b2v_custom_voice_id, "voice_id": c.voice_id, "name": c.name, "source": c.source,
+                        "preview_url": c.preview_url, "saved": c.voice_id in ids} for c in custom]}
+
+
+class SaveIn(BaseModel):
+    voice_id: str = Field(min_length=1, max_length=100)
+
+
+@router.post("/saved", status_code=201)
+def save_voice(body: SaveIn, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    custom = ctx.db.scalar(select(B2VCustomVoice).where(B2VCustomVoice.voice_id == body.voice_id,
+                                                        B2VCustomVoice.workspace_id == ctx.workspace.id))
+    if custom:
+        row = ctx.db.merge(UserSavedVoice(workspace_id=ctx.workspace.id, voice_id=custom.voice_id, name=custom.name,
+                                          preview_url=custom.preview_url, premium=True, is_custom=True))
+    else:
+        with upstream():
+            v = next((v for v in b2v.prebuilt_voices() if v.get("voice_id") == body.voice_id), None)
+        if not v:
+            raise HTTPException(404, "Voice not found")
+        if v.get("plan") == "paid":
+            video_limits.require_premium(ctx.db, ctx.workspace, "This voice")
+        row = _save_builtin(ctx, v)
+    ctx.db.commit()
+    return _voice_out(row)
+
+
+@router.delete("/saved/{voice_id}")
+def unsave_voice(voice_id: str, ctx: Ctx = Depends(get_ctx)):
+    row = ctx.db.get(UserSavedVoice, {"workspace_id": ctx.workspace.id, "voice_id": voice_id})
+    if not row:
+        raise HTTPException(404, "Voice not found")
+    ctx.db.delete(row)
+    ctx.db.commit()
+    return {"ok": True}
+
+
+# Design a voice ★: a description or options -> a few previews; keep one to make it a custom voice
+
+
+class DesignPromptIn(BaseModel):
+    prompt: str = Field(min_length=20, max_length=1000)
+
+
+class DesignPresetIn(BaseModel):
+    gender: str = Field("", max_length=30)
+    age: str = Field("", max_length=30)
+    persona: str = Field("", max_length=100)
+    speed: str = Field("", max_length=30)
+    accent: str = Field("", max_length=60)
+
+
+def _design(ctx: Ctx, path: str, body: dict) -> dict:
+    plan = video_limits.require_premium(ctx.db, ctx.workspace, "Designing a voice")
+    video_limits.take(ctx.db, ctx.workspace, "voice_designs_daily", plan=plan)
+    try:
+        with upstream():
+            data = b2v.request("POST", path, json=body, timeout=90) or {}
+    except HTTPException:
+        video_limits.give_back(ctx.db, ctx.workspace.id, "voice_designs_daily")
+        raise
+    return {"previews": [{k: p.get(k) for k in ("generated_voice_id", "audio_base_64", "media_type", "duration_secs")}
+                         for p in data.get("previews") or []]}
+
+
+@router.post("/design/prompt")
+def design_from_prompt(body: DesignPromptIn, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    return _design(ctx, "/api/voices/design-from-prompt", body.model_dump())
+
+
+@router.post("/design/preset")
+def design_from_preset(body: DesignPresetIn, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    return _design(ctx, "/api/voices/design-from-preset", body.model_dump())
+
+
+class KeepIn(BaseModel):
+    generated_voice_id: str = Field(min_length=1, max_length=200)
+    source: Literal["prompt", "preset"]
+    name: str = Field(min_length=1, max_length=100)
+    prompt_text: str | None = Field(None, max_length=1000)
+    preview_url: str | None = Field(None, max_length=1000)
+
+
+def _record_custom(ctx: Ctx, made: dict, source: str) -> dict:
+    row = B2VCustomVoice(b2v_custom_voice_id=int(made["id"]), workspace_id=ctx.workspace.id,
+                         voice_id=made["voice_id"], name=(made.get("name") or "My voice")[:255], source=source,
+                         preview_url=made.get("preview_url"))
+    ctx.db.add(row)
+    ctx.db.merge(UserSavedVoice(workspace_id=ctx.workspace.id, voice_id=row.voice_id, name=row.name,
+                                preview_url=row.preview_url, premium=True, is_custom=True))
+    ctx.db.commit()
+    return {"id": row.b2v_custom_voice_id, "voice_id": row.voice_id, "name": row.name, "source": source,
+            "preview_url": row.preview_url, "saved": True}
+
+
+def _make_custom(ctx: Ctx, source: str, send) -> dict:
+    plan = video_limits.require_premium(ctx.db, ctx.workspace, "Custom voices")
+    video_limits.take(ctx.db, ctx.workspace, "custom_voices", plan=plan)
+    try:
+        with upstream():
+            made = send()
+    except HTTPException:
+        video_limits.give_back(ctx.db, ctx.workspace.id, "custom_voices")
+        raise
+    return _record_custom(ctx, made, source)
+
+
+@router.post("/custom", status_code=201)
+def keep_designed_voice(body: KeepIn, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    """Keep one designed preview as a permanent custom voice."""
+    payload = {"voice_id": body.generated_voice_id, "source": "prompt" if body.source == "prompt" else "form",
+               "name": body.name, "prompt_text": body.prompt_text, "preview_url": body.preview_url}
+    return _make_custom(ctx, body.source,
+                        lambda: b2v.request("POST", "/api/voices/custom", json=payload, timeout=60))
+
+
+@router.post("/clone", status_code=201)
+async def clone_voice(name: str = Form(..., min_length=1, max_length=100), remove_background_noise: bool = Form(True),
+                      file: UploadFile = File(...), ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    """Clone a voice from one audio or video file (up to 50 MB)."""
+    data = await file.read(CLONE_MAX_BYTES + 1)
+    if not data:
+        raise HTTPException(400, "The file is empty.")
+    if len(data) > CLONE_MAX_BYTES:
+        raise HTTPException(400, "The file must be under 50 MB.")
+    form = {"name": name, "remove_background_noise": "true" if remove_background_noise else "false"}
+    files = {"file": (file.filename or "voice.mp3", data, file.content_type or "application/octet-stream")}
+    return _make_custom(ctx, "clone",
+                        lambda: b2v.request("POST", "/api/voices/clone", data=form, files=files, timeout=180))
+
+
+@router.get("/custom/{custom_id}/preview")
+def custom_preview(custom_id: int, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    row = b2v_access.owned_custom_voice(ctx, custom_id)
+    if row.preview_url:
+        return {"preview_url": row.preview_url, "ready": True}
+    with upstream():
+        result = b2v.request("GET", f"/api/voices/custom/{custom_id}/preview") or {}
+    if result.get("preview_url"):
+        row.preview_url = result["preview_url"]
+        saved = ctx.db.get(UserSavedVoice, {"workspace_id": ctx.workspace.id, "voice_id": row.voice_id})
+        if saved:
+            saved.preview_url = row.preview_url
+        ctx.db.commit()
+    return {"preview_url": result.get("preview_url"), "ready": bool(result.get("ready"))}
+
+
+@router.delete("/custom/{custom_id}")
+def delete_custom(custom_id: int, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    row = b2v_access.owned_custom_voice(ctx, custom_id)
+    try:
+        with upstream():
+            b2v.request("DELETE", f"/api/voices/custom/{custom_id}")
+    except HTTPException as e:
+        if e.status_code != 404:
+            raise
+    saved = ctx.db.get(UserSavedVoice, {"workspace_id": ctx.workspace.id, "voice_id": row.voice_id})
+    if saved:
+        ctx.db.delete(saved)
+    ctx.db.delete(row)
+    ctx.db.commit()
+    video_limits.give_back(ctx.db, ctx.workspace.id, "custom_voices")
+    return {"ok": True}
+
+
+# Voice sample ★: a few seconds of the chosen voice with the chosen tuning
+
+
+class SampleIn(BaseModel):
+    voice_gender: Literal["female", "male"] = "female"
+    voice_accent: str = Field("american", max_length=30)
+    custom_voice_id: str | None = Field(None, max_length=100)
+    voice_emotion: str | None = Field(None, max_length=200)
+    video_style: str | None = Field(None, max_length=40)
+
+
+@router.post("/sample")
+def voice_sample(body: SampleIn, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    plan = video_limits.require_premium(ctx.db, ctx.workspace, "Voice samples")
+    payload = body.model_dump(exclude_none=True)
+    with upstream():  # checking the voice may need blog2video's catalog
+        b2v_access.check_refs(ctx, {k: v for k, v in payload.items() if k != "voice_emotion"}, plan)
+    video_limits.take(ctx.db, ctx.workspace, "voice_samples_daily", plan=plan)
+    try:
+        with upstream():
+            audio, ctype = b2v.request("POST", "/api/voice/preview", json=payload, timeout=60, raw=True)
+    except HTTPException:
+        video_limits.give_back(ctx.db, ctx.workspace.id, "voice_samples_daily")
+        raise
+    return Response(audio, media_type=ctype or "audio/mpeg", headers={"Cache-Control": "no-store"})

backend/app/routers/videos.py

@@ -0,0 +1,742 @@
+"""Videos, made by blog2video: the 3-step wizard (Project, Template, Voice), script review, status and delete.
+Editing after creation is in video_edit.py; voices, templates and styles have their own routers.
+
+The browser only talks to these routes; the backend calls blog2video with our account's API key, which reaches
+every video we ever made. So every route that takes a video first checks it belongs to the current workspace
+(b2v_access.owned_video: 404 otherwise), and every create has its template, style and voice checked (check_refs).
+
+A video is an Artifact(type="video") with content_json.provider == "blog2video", so it shows up in the Library and
+Studio like everything else, plus a b2v_videos row: the ownership and allowance ledger. Routes take our artifact id.
+
+Videos made through the old partner integration have no b2v_videos row. blog2video answers 404 for them now, so
+they are "legacy": we keep showing the preview/video links we stored and refuse edits.
+"""
+
+import json
+import logging
+import re
+import uuid
+from collections.abc import Callable
+from contextlib import contextmanager
+from typing import Literal
+
+from fastapi import APIRouter, Depends, File, Form, HTTPException, UploadFile
+from pydantic import BaseModel, Field, ValidationError, model_validator
+from sqlalchemy import select
+
+from app.auth import Ctx, get_ctx
+from app.config import settings
+from app.models import Artifact, B2VVideo, Document, Notebook, Upload
+from app.routers.sources import is_locked
+from app.services import b2v_access, video_limits, video_quota
+from app.services import blog2video as b2v
+from app.services.artifacts import serialize_artifact
+from app.services.plans import Plan, plan_limit_error
+from app.services.storage import storage
+from app.services.video_quota import sync_video_quota, video_usage
+
+log = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api/videos", tags=["videos"])
+
+MIN_CONTENT = 50
+MAX_CONTENT = 100_000
+MAX_LINKS = 10
+MAX_POSTS = 200  # a notebook's posts, combined into one video (the ingest SCAN_CAP)
+MAX_FILES = 5
+FILE_MAX_BYTES = 5 * 1024 * 1024
+FILE_TYPES = {".pdf", ".docx", ".pptx", ".md", ".txt", ".vtt"}
+LOGO_MAX_BYTES = 2 * 1024 * 1024
+LOGO_TYPES = {"image/png", "image/jpeg", "image/webp", "image/svg+xml"}
+LANGUAGES = [("en", "English"), ("es", "Spanish"), ("fr", "French"), ("de", "German"), ("it", "Italian"),
+             ("pt", "Portuguese"), ("nl", "Dutch"), ("pl", "Polish"), ("hi", "Hindi"), ("ar", "Arabic"),
+             ("ja", "Japanese"), ("ko", "Korean"), ("zh", "Chinese"), ("tr", "Turkish"), ("ru", "Russian"),
+             ("id", "Indonesian")]
+
+# blog2video status -> our artifact status
+STATUS_MAP = {"failed": "failed", "error": "failed", "awaiting_stock_footage_review": "review",
+              "awaiting_script_review": "review", "rendering": "rendering"}
+# blog2video's statuses while an edit job runs on a finished video, kept on the artifact as they are so the list and
+# the editor can tell them from first generation: regenerating is a template switch (its relayout).
+JOB_STATUSES = {"regenerating", "voice_regenerating", "language_regenerating", "script_regenerating"}
+# Statuses the video list re-checks with blog2video, in case the work ended while nobody was watching.
+BUSY_STATUSES = JOB_STATUSES | {"generating", "rendering"}
+
+
+def b2v_ready(ctx: Ctx = Depends(get_ctx)) -> None:
+    if not b2v.configured():
+        raise HTTPException(503, {"code": "video_not_configured", "message": "Video is not set up yet."})
+    sync_video_quota(ctx.db, ctx.workspace)
+
+
+@contextmanager
+def upstream():
+    """blog2video errors -> our HTTP errors. Problems with our own blog2video account (out of videos, key or plan)
+    are not the user's: they get "temporarily unavailable" and ops get an ALERT log line."""
+    try:
+        yield
+    except b2v.Denied:
+        raise HTTPException(404, "Not found") from None
+    except b2v.NotFound as e:
+        raise HTTPException(404, str(e)) from None  # e.g. "Scene not found": the editor reloads
+    except (b2v.Busy, b2v.TemplateInUse) as e:
+        raise HTTPException(e.status, str(e)) from None
+    except b2v.BadRequest as e:
+        raise HTTPException(400, str(e)) from None
+    except b2v.B2VError as e:
+        raise HTTPException(e.status if e.status == 503 else 502, str(e)) from None
+
+
+ROW_FIELDS = {"video_url", "preview_url", "title"}
+
+
+def store(ctx: Ctx, a: Artifact, row: B2VVideo | None = None, **fields) -> None:
+    """Merge fields into content_json (and status), and the reference fields into the video's row, committing only
+    when something changed."""
+    if row is not None:
+        for key in ROW_FIELDS & fields.keys():
+            if fields[key] is not None and getattr(row, key) != fields[key]:
+                setattr(row, key, fields[key])
+                ctx.db.commit()
+    content = dict(a.content_json or {})
+    status = fields.pop("status", None)
+    changed = {k: v for k, v in fields.items() if v is not None and content.get(k) != v}
+    if changed or (status and status != a.status):
+        a.content_json = {**content, **changed}
+        if status:
+            a.status = status
+        ctx.db.commit()
+
+
+def sync_status(ctx: Ctx, a: Artifact, row: B2VVideo, s: dict) -> None:
+    raw = str(s.get("status") or "")
+    video_quota.record_status(ctx.db, row, "failed" if s.get("error") and raw not in STATUS_MAP else raw)
+    if s.get("error") or raw in STATUS_MAP:
+        status = STATUS_MAP.get(raw, "failed")
+    elif raw in JOB_STATUSES:
+        status = raw
+    elif s.get("ready") or raw in {"generated", "done"}:
+        status = "ready"
+    else:
+        status = "generating"
+    store(ctx, a, row, status=status, b2v_status=raw or None, step=s.get("step"), video_url=s.get("video_url"),
+          error=s.get("error"))
+
+
+# The wizard's options (every field of blog2video's 3 steps)
+
+
+class VideoOptions(BaseModel):
+    # Step 1: Project (script review is always off: blog2video goes straight to the video)
+    stock_footage_enabled: bool = True
+    aspect_ratio: Literal["landscape", "portrait"] = "landscape"
+    video_length: Literal["short", "medium", "detailed", "more_detailed"] = "short"
+    logo_upload_id: uuid.UUID | None = None  # a file uploaded through /api/storage/uploads
+    logo_position: Literal["bottom_right", "bottom_left", "top_left", "top_right"] = "bottom_right"
+    logo_opacity: float = Field(0.9, ge=0.1, le=1.0)
+    # Step 2: Template
+    template: str = Field("default", max_length=100)
+    video_style: str = Field("auto", max_length=40)
+    accent_color: str | None = Field(None, pattern=r"^#[0-9a-fA-F]{6}$")
+    bg_color: str | None = Field(None, pattern=r"^#[0-9a-fA-F]{6}$")
+    text_color: str | None = Field(None, pattern=r"^#[0-9a-fA-F]{6}$")
+    # Step 3: Voice
+    content_language: str | None = Field(None, max_length=10)  # None = detect from the content
+    voice_gender: Literal["female", "male", "none"] = "female"
+    voice_accent: str = Field("american", max_length=30)
+    custom_voice_id: str | None = Field(None, max_length=100)
+    voice_emotion: str | None = Field(None, max_length=200)  # ["<expressiveness>","<speed>","<emotion>",...]
+    bgm_track_id: str | None = Field(None, max_length=100)
+    bgm_volume: float = Field(0.10, ge=0, le=1)
+
+    def payload(self) -> dict:
+        """The fields blog2video takes, as it names them."""
+        # Only the wizard's own fields: a subclass (VideoCreateIn) adds the source, which is sent separately.
+        data = self.model_dump(include=set(VideoOptions.model_fields) - {"logo_upload_id"}, exclude_none=True,
+                               mode="json")
+        data["script_review_enabled"] = False
+        if self.voice_gender == "none":
+            data.pop("custom_voice_id", None)
+            data.pop("voice_emotion", None)
+        if not self.bgm_track_id:
+            data.pop("bgm_volume", None)
+        return data
+
+
+class VideoCreateIn(VideoOptions):
+    # Source: exactly one of these. document_ids are a notebook's ticked posts, combined into one video.
+    document_id: uuid.UUID | None = None
+    document_ids: list[uuid.UUID] | None = Field(None, min_length=1, max_length=MAX_POSTS)
+    url: str | None = Field(None, max_length=2000)
+    content: str | None = Field(None, max_length=MAX_CONTENT)
+    title: str | None = Field(None, max_length=300)
+    notebook_id: uuid.UUID | None = None  # names a combined video after its notebook
+
+    @model_validator(mode="after")
+    def one_source(self):
+        if sum(x is not None for x in (self.document_id, self.document_ids, self.url, self.content)) != 1:
+            raise ValueError("Pick one source: a notebook, a post, a link or pasted text")
+        if self.document_ids and len(self.document_ids) == 1:
+            self.document_id, self.document_ids = self.document_ids[0], None
+        return self
+
+
+class VideoBatchIn(VideoOptions):
+    urls: list[str] = Field(min_length=1, max_length=MAX_LINKS)
+
+
+def _not_indexed(count: int) -> HTTPException:
+    return HTTPException(400, f"{count} of these posts {'is' if count == 1 else 'are'} not indexed on your plan. "
+                              "Untick them or upgrade to index your whole archive.")
+
+
+def _combined(ctx: Ctx, body: VideoCreateIn) -> tuple[str, str]:
+    """Several posts as one text, oldest first, each given an equal share so none is cut off entirely."""
+    ids = set(body.document_ids or [])
+    docs = list(ctx.db.scalars(select(Document).where(Document.id.in_(ids),
+                                                      Document.workspace_id == ctx.workspace.id)))
+    if len(docs) != len(ids):
+        raise HTTPException(404, "Post not found")
+    locked = sum(is_locked(d) for d in docs)
+    if locked:
+        raise _not_indexed(locked)
+    docs.sort(key=lambda d: (d.published_at is None, d.published_at.timestamp() if d.published_at else 0))
+    share = MAX_CONTENT // len(docs)
+    text = "\n\n".join(f"# {d.title}\n\n{(d.clean_text or '').strip()}"[:share] for d in docs)
+    nb = ctx.db.scalar(select(Notebook).where(Notebook.id == body.notebook_id,
+                                              Notebook.workspace_id == ctx.workspace.id)) if body.notebook_id else None
+    return (nb.title if nb else f"{docs[0].title} + {len(docs) - 1} more"), text
+
+
+def _source(ctx: Ctx, body: VideoCreateIn) -> tuple[dict, str]:
+    """The blog2video source fields and a title for our artifact."""
+    if body.document_ids:
+        title, text = _combined(ctx, body)
+    elif body.document_id:
+        doc = ctx.db.scalar(select(Document).where(Document.id == body.document_id,
+                                                   Document.workspace_id == ctx.workspace.id))
+        if not doc:
+            raise HTTPException(404, "Post not found")
+        if is_locked(doc):
+            raise _not_indexed(1)
+        if re.match(r"https?://", doc.url or ""):
+            return {"url": doc.url, "title": doc.title[:255]}, doc.title
+        # Uploaded files have no public link (upload://name): send their text instead.
+        title, text = doc.title, doc.clean_text or ""
+    elif body.url:
+        if not re.match(r"https?://", body.url):
+            raise HTTPException(400, "Enter a link that starts with http:// or https://")
+        return {"url": body.url}, body.title or body.url
+    else:
+        title, text = body.title or "", body.content or ""
+        if not title.strip():
+            raise HTTPException(400, "Give the pasted text a title")
+    text = text.strip()
+    if len(text) < MIN_CONTENT:
+        raise HTTPException(400, f"Add at least {MIN_CONTENT} characters of text")
+    return {"content": text[:MAX_CONTENT], "title": title[:255]}, title
+
+
+def _metadata(ctx: Ctx, row: B2VVideo, **extra) -> dict:
+    """Sent with every create, and returned by blog2video: ties the video back to us from its side too."""
+    return {"workspace_id": str(ctx.workspace.id), "user_id": str(ctx.user.id), "video_ref": str(row.id), **extra}
+
+
+def _check(ctx: Ctx, options: VideoOptions) -> tuple[dict, Plan]:
+    payload = options.payload()
+    with upstream():  # checking a template or voice may need blog2video's catalog
+        plan = b2v_access.check_refs(ctx, payload)
+    accent = (ctx.workspace.brand_json or {}).get("accent")
+    if plan.brand_kit and accent and "accent_color" not in payload:
+        payload["accent_color"] = accent
+    return payload, plan
+
+
+def _logo(ctx: Ctx, upload_id: uuid.UUID | None) -> tuple[str, str, bytes] | None:
+    if not upload_id:
+        return None
+    upload = ctx.db.scalar(select(Upload).where(Upload.id == upload_id, Upload.workspace_id == ctx.workspace.id))
+    if not upload or upload.status != "complete" or upload.content_type not in LOGO_TYPES:
+        raise HTTPException(400, "The logo must be a PNG, JPG, WebP or SVG.")
+    data = storage.get_bytes(upload.key)
+    if len(data) > LOGO_MAX_BYTES:
+        raise HTTPException(400, "The logo must be under 2 MB.")
+    return upload.filename, upload.content_type, data
+
+
+def _start(ctx: Ctx, plan: Plan, title: str, aspect_ratio: str, template: str, created_via: str,
+           call: Callable[[B2VVideo], int], logo: tuple[str, str, bytes] | None = None,
+           document_id: uuid.UUID | None = None, source_url: str | None = None) -> Artifact:
+    """Reserve one video, record it, ask blog2video for it (call returns its id), refund if that fails."""
+    if not video_quota.reserve(ctx.db, ctx.workspace.id):
+        usage = video_usage(ctx.db, ctx.workspace)
+        raise plan_limit_error(plan, "videos",
+                               f"You have made {usage['used']} of {usage['limit']} videos this period.")
+    try:
+        artifact = Artifact(workspace_id=ctx.workspace.id, type="video", status="generating", document_id=document_id,
+                            content_json={"provider": "blog2video", "title": title[:300],
+                                          "aspect_ratio": aspect_ratio})
+        ctx.db.add(artifact)
+        ctx.db.flush()
+        row = B2VVideo(workspace_id=ctx.workspace.id, user_id=ctx.user.id, artifact_id=artifact.id,
+                       created_via=created_via, template_ref=template, title=title[:300], source_url=source_url,
+                       aspect_ratio=aspect_ratio,
+                       # Keys are unique across our whole blog2video account, so they start with the workspace id.
+                       idempotency_key=f"{ctx.workspace.id}:{uuid.uuid4()}" if created_via == "v1" else None)
+        ctx.db.add(row)
+        ctx.db.commit()
+    except Exception:
+        ctx.db.rollback()
+        video_quota.unreserve(ctx.db, ctx.workspace.id)
+        raise
+    try:
+        with upstream():
+            vid = call(row)
+    except HTTPException:
+        # Refused, or no answer after every retry: the user gets the video back.
+        video_quota.refund(ctx.db, row, "failed")
+        ctx.db.delete(artifact)
+        ctx.db.commit()
+        raise
+    row.b2v_video_id, row.status = vid, "queued"
+    ctx.db.commit()
+    store(ctx, artifact, row, b2v_video_id=vid, b2v_status="queued")
+    if logo:
+        try:
+            b2v.upload_logo(vid, *logo)
+        except b2v.B2VError:
+            log.warning("logo upload failed for video artifact %s", artifact.id)  # the video is made without it
+    return artifact
+
+
+@router.post("", status_code=201)
+def create_video(body: VideoCreateIn, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    """From a link, pasted text or one of the workspace's posts: POST /api/v1/videos, which starts generating."""
+    source, title = _source(ctx, body)
+    payload, plan = _check(ctx, body)
+    logo = _logo(ctx, body.logo_upload_id)
+
+    def call(row: B2VVideo) -> int:
+        # Retried with the same key on no answer: blog2video returns the same video, charged once.
+        created = b2v.create_video({**source, **payload, "external_user_id": str(ctx.workspace.id),
+                                    "metadata": _metadata(ctx, row, artifact_id=str(row.artifact_id),
+                                                          document_id=str(body.document_id) if body.document_id
+                                                          else None,
+                                                          document_ids=[str(d) for d in body.document_ids or []]
+                                                          or None)},
+                                   row.idempotency_key)
+        return int(created["video_id"])
+
+    a = _start(ctx, plan, title, body.aspect_ratio, body.template, "v1", call, logo, body.document_id,
+               source_url=source.get("url"))
+    return serialize_artifact(a)
+
+
+@router.post("/batch", status_code=201)
+def create_videos(body: VideoBatchIn, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    """Multi-link: one video per link, each charged and keyed on its own. Background music is single-video only."""
+    urls = [u.strip() for u in body.urls if re.match(r"https?://\S+", u.strip())]
+    if not urls:
+        raise HTTPException(400, "Enter at least one link that starts with http:// or https://")
+    options = body.model_copy(update={"bgm_track_id": None})
+    payload, plan = _check(ctx, options)
+    logo = _logo(ctx, body.logo_upload_id)
+    made: list[dict] = []
+    for url in urls:
+        def call(row: B2VVideo, url=url) -> int:
+            created = b2v.create_video({"url": url, **payload, "external_user_id": str(ctx.workspace.id),
+                                        "metadata": _metadata(ctx, row, artifact_id=str(row.artifact_id))},
+                                       row.idempotency_key)
+            return int(created["video_id"])
+
+        try:
+            made.append(serialize_artifact(_start(ctx, plan, url, body.aspect_ratio, body.template, "v1", call,
+                                                  logo, source_url=url)))
+        except HTTPException as e:
+            if not made:
+                raise
+            # Keep what was made; say where it stopped (usually the allowance ran out).
+            detail = e.detail if isinstance(e.detail, str) else (e.detail or {}).get("message")
+            made.append({"error": detail, "url": url})
+            break
+    return made
+
+
+@router.post("/upload", status_code=201)
+async def create_from_files(files: list[UploadFile] = File(...), options: str = Form("{}"),
+                            ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    """From up to 5 documents (pdf, docx, pptx, md, txt, vtt; 5 MB each): blog2video parses them itself.
+    `options` is the wizard's VideoOptions as JSON."""
+    try:
+        opts = VideoOptions.model_validate(json.loads(options or "{}"))
+    except (ValueError, ValidationError) as e:
+        raise HTTPException(422, str(e)[:500]) from None
+    if not files or len(files) > MAX_FILES:
+        raise HTTPException(400, f"Add 1 to {MAX_FILES} files.")
+    parts: list[tuple[str, bytes, str]] = []
+    for f in files:
+        name = f.filename or "document"
+        if not any(name.lower().endswith(ext) for ext in FILE_TYPES):
+            raise HTTPException(400, f"{name}: use PDF, DOCX, PPTX, MD, TXT or VTT.")
+        data = await f.read(FILE_MAX_BYTES + 1)
+        if len(data) > FILE_MAX_BYTES:
+            raise HTTPException(400, f"{name} is over 5 MB.")
+        parts.append((name, data, f.content_type or "application/octet-stream"))
+    payload, plan = _check(ctx, opts)
+    logo = _logo(ctx, opts.logo_upload_id)
+    title = parts[0][0].rsplit(".", 1)[0] if len(parts) == 1 else f"{len(parts)} documents"
+    form = {k: (str(v).lower() if isinstance(v, bool) else str(v)) for k, v in payload.items()}
+
+    def call(row: B2VVideo) -> int:
+        project = b2v.upload_project({**form, "name": title[:255]}, parts)
+        pid = int(project["id"])
+        try:
+            b2v.generate(pid)
+        except b2v.B2VError:
+            try:
+                b2v.delete_project(pid)
+            except b2v.B2VError:
+                log.warning("could not remove blog2video project %s after generate failed", pid)
+            raise
+        return pid
+
+    a = _start(ctx, plan, title, opts.aspect_ratio, opts.template, "upload", call, logo)
+    return serialize_artifact(a)
+
+
+# Read
+
+
+@router.get("/config")
+def video_config(ctx: Ctx = Depends(get_ctx)):
+    return {"configured": b2v.configured(), **video_limits.report(ctx.db, ctx.workspace)}
+
+
+@router.get("/quota")
+def quota(ctx: Ctx = Depends(get_ctx)):
+    return video_usage(ctx.db, ctx.workspace)
+
+
+def _with_posters(t: dict) -> dict:
+    """Poster images for the template picker. Built-in templates have baked posters on blog2video's web app (a few
+    have none; the picker then shows the template's colors); designer templates carry their own image."""
+    if t.get("preview_image_url") and not t.get("preview_url"):
+        return {**t, "preview_url": t["preview_image_url"]}
+    if t.get("preview_url") or not t.get("id") or str(t["id"]).startswith("crafted_"):
+        return t
+    base = f"{settings.b2v_app_url.rstrip('/')}/template-posters/{t['id']}"
+    return {**t, "preview_url": f"{base}.webp", "preview_portrait_url": f"{base}-portrait.webp"}
+
+
+@router.get("/catalog")
+def catalog(ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    """What the wizard offers this workspace: built-in and designer templates, its own ready custom templates,
+    built-in and its own styles, music, languages. Nothing another workspace made."""
+    with upstream():
+        builtin = b2v.builtin_templates()
+        try:
+            crafted = b2v.crafted_templates()
+        except b2v.B2VError:
+            crafted = []
+        mine = [{"id": f"custom_{t.b2v_template_id}", "name": t.name, "custom": True}
+                for t in b2v_access.my_templates(ctx, ready_only=True)]
+        styles = b2v_access.visible_styles(ctx)
+        music = b2v.music_tracks()
+    return {"templates": [_with_posters(t) for t in builtin if isinstance(t, dict)],
+            "crafted_templates": [_with_posters(t) for t in crafted if isinstance(t, dict)],
+            "my_templates": mine, "video_styles": styles,
+            "music": music, "languages": [{"code": c, "name": n} for c, n in LANGUAGES]}
+
+
+def _restore_missing_artifacts(ctx: Ctx) -> None:
+    """A video whose Library item is gone but which was never deleted (b2v_videos is the record) gets its item back,
+    rebuilt from the row. E.g. items removed by the Library's delete before it also removed the blog2video video."""
+    orphans = ctx.db.scalars(select(B2VVideo).where(
+        B2VVideo.workspace_id == ctx.workspace.id, B2VVideo.artifact_id.is_(None),
+        B2VVideo.b2v_video_id.is_not(None), B2VVideo.status != "deleted",
+        B2VVideo.quota_state != "refunded")).all()
+    for row in orphans:
+        status = ("ready" if row.status in video_quota.FINISHED else
+                  "failed" if row.status in video_quota.FAILED else
+                  row.status if row.status in JOB_STATUSES else STATUS_MAP.get(row.status, "generating"))
+        a = Artifact(workspace_id=ctx.workspace.id, type="video", status=status,
+                     content_json={k: v for k, v in {
+                         "provider": "blog2video", "b2v_video_id": row.b2v_video_id, "b2v_status": row.status,
+                         "title": row.title or "Video", "aspect_ratio": row.aspect_ratio,
+                         "preview_url": row.preview_url, "video_url": row.video_url}.items() if v is not None})
+        ctx.db.add(a)
+        ctx.db.flush()
+        row.artifact_id = a.id
+    if orphans:
+        ctx.db.commit()
+
+
+def _needs_title(row: B2VVideo) -> bool:
+    return not row.title or row.title == row.source_url or bool(re.match(r"https?://", row.title))
+
+
+def _set_title(ctx: Ctx, row: B2VVideo, a: Artifact | None, name: str | None) -> None:
+    """blog2video names a video after reading its source; until then we only had the link."""
+    name = (name or "").strip()[:300]
+    if not name or re.match(r"https?://", name) or row.title == name:
+        return
+    row.title = name
+    if a is not None:
+        a.content_json = {**(a.content_json or {}), "title": name}
+    ctx.db.commit()
+
+
+def _refresh_titles(ctx: Ctx, pairs: list[tuple[Artifact, B2VVideo]]) -> None:
+    """Real titles for videos still titled by their link, from blog2video's video list (one call)."""
+    todo = {row.b2v_video_id: (a, row) for a, row in pairs
+            if row.created_via == "v1" and row.b2v_video_id and _needs_title(row)}
+    if not todo or not b2v.configured():
+        return
+    try:
+        listed = b2v.request("GET", "/api/v1/videos", params={"external_user_id": str(ctx.workspace.id), "limit": 100})
+    except b2v.B2VError as e:
+        log.warning("could not refresh video titles: %s", e)
+        return
+    for item in (listed or {}).get("items") or []:
+        if item.get("video_id") in todo:
+            a, row = todo[item["video_id"]]
+            _set_title(ctx, row, a, item.get("name"))
+
+
+@router.get("")
+def list_videos(ctx: Ctx = Depends(get_ctx), limit: int = 30, offset: int = 0):
+    """The workspace's videos, newest first, with what the list rows show: title, status, source, scenes, date."""
+    _restore_missing_artifacts(ctx)
+    arts = [a for a in ctx.db.scalars(
+        select(Artifact).where(Artifact.workspace_id == ctx.workspace.id, Artifact.type == "video")
+        .order_by(Artifact.created_at.desc()).limit(min(limit, 100)).offset(offset)
+    ).all() if (a.content_json or {}).get("provider") == "blog2video"]
+    rows = {r.artifact_id: r for r in ctx.db.scalars(
+        select(B2VVideo).where(B2VVideo.artifact_id.in_([a.id for a in arts])))} if arts else {}
+    _refresh_titles(ctx, [(a, rows[a.id]) for a in arts if a.id in rows])
+    _refresh_busy(ctx, [(a, rows[a.id]) for a in arts if a.id in rows])
+    out = []
+    for a in arts:
+        row, content = rows.get(a.id), a.content_json or {}
+        out.append({**serialize_artifact(a), "source_url": row.source_url if row else None,
+                    "scenes": content.get("scenes"), "b2v_status": (row.status if row else content.get("b2v_status"))})
+    return out
+
+
+def _refresh_busy(ctx: Ctx, pairs: list[tuple[Artifact, B2VVideo]], limit: int = 10) -> None:
+    """Ask blog2video about videos still generating, rendering or in an edit job, so one that finished (or failed)
+    while nobody had it open shows its real state. A few per page; a blog2video hiccup leaves the stored status."""
+    busy = [(a, r) for a, r in pairs if a.status in BUSY_STATUSES and r.b2v_video_id is not None][:limit]
+    for a, row in busy:
+        try:
+            sync_status(ctx, a, row, b2v.status(row.b2v_video_id, row.created_via))
+        except b2v.B2VError as e:
+            log.info("status refresh for video %s skipped: %s", row.b2v_video_id, e)
+
+
+def _legacy(a: Artifact) -> dict:
+    content = a.content_json or {}
+    return {"legacy": True, "status": content.get("b2v_status"), "ready": bool(content.get("video_url")),
+            "video_url": content.get("video_url"), "preview_url": content.get("preview_url"),
+            "artifact_status": a.status, "artifact": serialize_artifact(a)}
+
+
+@router.get("/{artifact_id}/status")
+def video_status(artifact_id: uuid.UUID, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    a, vid, row = b2v_access.owned_video(ctx, artifact_id)
+    if row is None:
+        return _legacy(a)
+    try:
+        with upstream():
+            s = b2v.status(vid, row.created_via)
+    except HTTPException as e:
+        if e.status_code != 404:
+            raise
+        s = {"status": "failed", "error": "The video service lost this video."}
+    sync_status(ctx, a, row, s)
+    return {**s, "video_id": vid, "artifact_status": a.status}
+
+
+def preview_url(ctx: Ctx, a: Artifact, vid: int, row: B2VVideo | None = None) -> str | None:
+    """The public live-preview link (no key needed, safe for the browser). Minted once and kept."""
+    url = (row.preview_url if row else None) or (a.content_json or {}).get("preview_url")
+    if url:
+        return url
+    try:
+        url = (b2v.preview_token(vid) or {}).get("preview_url")
+    except b2v.B2VError as e:
+        log.warning("preview token for video %s failed: %s", vid, e)
+        return None
+    store(ctx, a, row, preview_url=url)
+    return url
+
+
+def _media_url(project_id: int, asset: dict | None, subdir: str, filename: str) -> str:
+    if asset and asset.get("r2_url"):
+        return asset["r2_url"]
+    return f"{settings.b2v_api_base_url.rstrip('/')}/media/projects/{project_id}/{subdir}/{filename}"
+
+
+def _enrich(project: dict) -> dict:
+    """What the scene rows show, worked out once here: each scene's audio and image links (blog2video only gives
+    file names), its layout and font sizes, and totals for the preview caption."""
+    pid = project.get("id")
+    assets = [a for a in project.get("assets") or [] if not a.get("excluded")]
+    latest: dict[tuple[str, str], dict] = {}
+    for a in sorted(assets, key=lambda a: a.get("id") or 0):  # a regenerated file is a newer asset, same name
+        latest[(a.get("asset_type"), a.get("filename"))] = a
+    total, images = 0.0, 0
+    scenes = []
+    for sc in sorted(project.get("scenes") or [], key=lambda s: s.get("order") or 0):
+        try:
+            code = json.loads(sc.get("remotion_code") or "{}")
+        except ValueError:
+            code = {}
+        custom = str(project.get("template") or "").startswith("custom_")
+        props = (code.get("layoutConfig") if custom else code.get("layoutProps")) or {}
+        audio = None
+        if sc.get("voiceover_path"):
+            name = re.split(r"[/\\]", sc["voiceover_path"])[-1]
+            asset = latest.get(("audio", name))
+            audio = _media_url(pid, asset, "audio", name) + (f"?v={asset['id']}" if asset else "")
+        pics = []
+        # Stills sit in assignedImage(s); a stock clip in assignedVideo(s). Both fill the scene's visual slot.
+        for key in ("assignedImage", "assignedImages", "image", "images", "assignedVideo", "assignedVideos"):
+            vals = props.get(key)
+            clip = key.startswith("assignedVideo")
+            for name in ([vals] if isinstance(vals, str) else vals if isinstance(vals, list) else []):
+                if isinstance(name, str) and name and not name.startswith("http"):
+                    first, second = ("video", "image") if clip else ("image", "video")
+                    asset = latest.get((first, name)) or latest.get((second, name))
+                    kind = asset.get("asset_type") if asset else first
+                    pics.append({"filename": name, "asset_id": asset.get("id") if asset else None, "kind": kind,
+                                 "url": _media_url(pid, asset, "videos" if kind == "video" else "images", name)})
+        images += len(pics)
+        total += float(sc.get("duration_seconds") or 0) + float(sc.get("extra_hold_seconds") or 0)
+        scenes.append({**sc, "audio_url": audio, "images": pics,
+                       "layout": code.get("layout") or sc.get("preferred_layout"),
+                       "title_font_size": props.get("titleFontSize"),
+                       "desc_font_size": props.get("descriptionFontSize")})
+    return {**project, "scenes": scenes,
+            "summary": {"scenes": len(scenes), "duration_seconds": round(total),
+                        "images": sum(1 for a in assets if a.get("asset_type") == "image") or images,
+                        "clips": sum(1 for a in assets if a.get("asset_type") == "video")}}
+
+
+@router.get("/{artifact_id}")
+def get_video(artifact_id: uuid.UUID, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    a, vid, row = b2v_access.owned_video(ctx, artifact_id)
+    if row is None:
+        return _legacy(a)
+    with upstream():
+        project = b2v.get_project(vid)
+    if row is not None:
+        _set_title(ctx, row, a, project.get("name"))
+    store(ctx, a, row, video_url=project.get("r2_video_url"), scenes=len(project.get("scenes") or []) or None)
+    return {"video_id": vid, "status": project.get("status"), "project": _enrich(project),
+            "preview_url": preview_url(ctx, a, vid, row), "video_url": project.get("r2_video_url"),
+            "artifact": serialize_artifact(a)}
+
+
+@router.delete("/{artifact_id}")
+def delete_video(artifact_id: uuid.UUID, ctx: Ctx = Depends(get_ctx)):
+    """Removes it from Notestack and from blog2video."""
+    a, _, _ = b2v_access.owned_video(ctx, artifact_id)
+    remove_video(ctx, a)
+    return {"ok": True}
+
+
+def remove_video(ctx: Ctx, a: Artifact) -> None:
+    """Delete the video on blog2video, then the artifact. The b2v_videos row stays as the record that it was made
+    (status "deleted"): a lifetime allowance (Free) must not get a video back because one was deleted."""
+    row = ctx.db.scalar(select(B2VVideo).where(B2VVideo.artifact_id == a.id, B2VVideo.workspace_id == ctx.workspace.id))
+    if row is not None and row.b2v_video_id is not None and b2v.configured():
+        try:
+            b2v.delete_project(row.b2v_video_id)
+        except b2v.NotFound:
+            pass
+        except b2v.B2VError as e:
+            raise HTTPException(502, str(e)) from None
+    if row is not None:
+        row.status, row.artifact_id = "deleted", None
+    ctx.db.delete(a)
+    ctx.db.commit()
+
+
+# Script review (status awaiting_script_review): read, rewrite with AI, approve
+
+
+class DraftScene(BaseModel):
+    id: int
+    title: str = Field(max_length=255)
+    display_text: str | None = Field(None, max_length=3000)
+    narration_text: str = Field(max_length=6000)
+
+
+class ReviewPreviewIn(BaseModel):
+    title: str = Field(min_length=1, max_length=255)
+    display_text: str = Field(min_length=1, max_length=3000)
+    narration_text: str = Field("", max_length=6000)
+    draft_scenes: list[DraftScene] = Field(max_length=200)
+    revision: int = Field(0, ge=0)
+
+
+class ReviewAiIn(ReviewPreviewIn):
+    instruction: str = Field(min_length=2, max_length=1000)
+
+
+class ReviewApproveScene(DraftScene):
+    preferred_layout: str | None = Field(None, max_length=100)
+    source_fingerprint: str | None = Field(None, max_length=200)
+    accepted_ai_instructions: list[str] = Field(default_factory=list, max_length=10)
+
+
+class ReviewApproveIn(BaseModel):
+    scenes: list[ReviewApproveScene] = Field(max_length=200)
+
+
+@router.get("/{artifact_id}/script")
+def get_script(artifact_id: uuid.UUID, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    _, vid, _ = b2v_access.video_or_404(ctx, artifact_id)
+    with upstream():
+        project = b2v.get_project(vid)
+    scenes = sorted(project.get("scenes") or [], key=lambda s: s.get("order", 0))
+    return {"status": project.get("status"), "scenes": [
+        {k: s.get(k) for k in ("id", "order", "title", "display_text", "narration_text", "preferred_layout")}
+        for s in scenes]}
+
+
+@router.post("/{artifact_id}/script/scenes/{scene_id}/narration-preview")
+def narration_preview(artifact_id: uuid.UUID, scene_id: int, body: ReviewPreviewIn, ctx: Ctx = Depends(get_ctx),
+                      _: None = Depends(b2v_ready)):
+    """Rewrite one scene's narration to match its edited title and text."""
+    _, vid, _ = b2v_access.video_or_404(ctx, artifact_id)
+    with upstream():
+        return b2v.project_call("POST", vid, f"script-review/scenes/{scene_id}/narration-preview",
+                                json=body.model_dump(), timeout=60)
+
+
+@router.post("/{artifact_id}/script/scenes/{scene_id}/ai-preview")
+def ai_preview(artifact_id: uuid.UUID, scene_id: int, body: ReviewAiIn, ctx: Ctx = Depends(get_ctx),
+               _: None = Depends(b2v_ready)):
+    """★ Rewrite one scene from an instruction. Uses one AI edit."""
+    _, vid, _ = b2v_access.video_or_404(ctx, artifact_id)
+    plan = video_limits.require_premium(ctx.db, ctx.workspace, "AI rewrites")
+    video_limits.take(ctx.db, ctx.workspace, "ai_edits", plan=plan)
+    try:
+        with upstream():
+            return b2v.project_call("POST", vid, f"script-review/scenes/{scene_id}/ai-preview",
+                                    json=body.model_dump(), timeout=60)
+    except HTTPException:
+        video_limits.give_back(ctx.db, ctx.workspace.id, "ai_edits")
+        raise
+
+
+@router.post("/{artifact_id}/script/approve")
+def approve_script(artifact_id: uuid.UUID, body: ReviewApproveIn, ctx: Ctx = Depends(get_ctx),
+                   _: None = Depends(b2v_ready)):
+    a, vid, _ = b2v_access.video_or_404(ctx, artifact_id)
+    with upstream():
+        result = b2v.project_call("POST", vid, "script-review/approve", json=body.model_dump(), timeout=60)
+    store(ctx, a, status="generating")
+    return result

backend/app/services/artifacts.py

@@ -62,8 +62,11 @@ def serialize_artifact(a: Artifact, job: Job | None = None) -> dict:
         "document_id": str(a.document_id) if a.document_id else None,
         "content": content,
         "storage_key": a.storage_key,
-        "url": storage.presign_get(a.storage_key) if a.storage_key else None,
-        "download_url": storage.presign_get(a.storage_key, download_name=_download_name(a)) if a.storage_key else None,
+        # blog2video videos live on blog2video's storage (video_url once rendered)
+        "url": storage.presign_get(a.storage_key) if a.storage_key else content.get("video_url"),
+        "download_url": (storage.presign_get(a.storage_key, download_name=_download_name(a)) if a.storage_key
+                         else content.get("video_url")),
+        "provider": content.get("provider"),
         "slide_urls": [storage.presign_get(k) for k in slides],
         "created_at": a.created_at.isoformat() if a.created_at else None,
         "job": serialize_job(job) if job else None,

backend/app/services/auth_identity.py

@@ -9,6 +9,7 @@ from sqlalchemy import select
 from sqlalchemy.orm import Session
 
 from app.models import AuthProvider, Subscription, User, Workspace, WorkspaceMember
+from app.services.plans import PLANS
 
 
 class IdentityError(Exception):
@@ -65,7 +66,9 @@ def _bootstrap_workspace(db: Session, user: User) -> None:
     db.add(workspace)
     db.flush()
     db.add(WorkspaceMember(workspace_id=workspace.id, user_id=user.id, role="owner"))
-    db.add(Subscription(workspace_id=workspace.id, plan="free"))
+    free = PLANS["free"]
+    db.add(Subscription(workspace_id=workspace.id, plan="free", video_plan=free.id, video_limit=free.videos,
+                        videos_period_start=datetime.now(UTC)))
 
 
 def resolve_or_create_google_user(

backend/app/services/b2v_access.py

@@ -0,0 +1,179 @@
+"""Who owns what on our one blog2video account.
+
+blog2video's ownership checks stop at the account: any video, custom template, custom voice or style made with our
+key can be used, listed and edited with it. So every route that takes a blog2video id checks here first that it
+belongs to the current workspace (404 otherwise, so another workspace's ids are never confirmed), and every create or
+edit body has its references checked before it is forwarded (check_refs).
+"""
+
+import uuid
+
+from fastapi import HTTPException
+from sqlalchemy import select
+
+from app.auth import Ctx
+from app.models import Artifact, B2VCustomVoice, B2VStyle, B2VTemplate, B2VVideo
+from app.services import blog2video as b2v
+from app.services.plans import Plan, effective_plan
+from app.services.video_limits import require_premium
+
+BUILTIN_STYLES = {"auto", "explainer", "storytelling", "promotional"}
+PREMIUM_LENGTHS = {"detailed", "more_detailed", "mdetailed"}
+
+
+def not_found(what: str = "Not found") -> HTTPException:
+    return HTTPException(404, what)
+
+
+# Videos
+
+
+def owned_video(ctx: Ctx, artifact_id: uuid.UUID) -> tuple[Artifact, int, B2VVideo | None]:
+    """The artifact, blog2video's id, and our ledger row (None for videos made before the API key).
+
+    The row is the reference: its b2v_video_id (and created_via) is what every blog2video call uses. The artifact's
+    content_json only keeps a copy for the Library, and is read only for legacy videos, which have no row."""
+    a = ctx.db.scalar(select(Artifact).where(Artifact.id == artifact_id, Artifact.workspace_id == ctx.workspace.id,
+                                             Artifact.type == "video"))
+    content = (a.content_json or {}) if a else {}
+    if not a or content.get("provider") != "blog2video":
+        raise not_found("Video not found")
+    row = ctx.db.scalar(select(B2VVideo).where(B2VVideo.artifact_id == a.id,
+                                               B2VVideo.workspace_id == ctx.workspace.id))
+    if row is not None and row.b2v_video_id is not None:
+        return a, row.b2v_video_id, row
+    if row is None and content.get("b2v_video_id"):
+        return a, int(content["b2v_video_id"]), None  # legacy
+    raise not_found("Video not found")  # the create never got an id from blog2video
+
+
+def video_or_404(ctx: Ctx, artifact_id: uuid.UUID) -> tuple[Artifact, int, B2VVideo]:
+    """A video this workspace owns and blog2video can still reach with our key."""
+    a, vid, row = owned_video(ctx, artifact_id)
+    if row is None:
+        raise HTTPException(410, {"code": "video_legacy",
+                                  "message": "This video was made before the video service changed and can not be "
+                                             "edited any more. Its links still work."})
+    return a, vid, row
+
+
+# Templates, voices, styles
+
+
+def owned_template(ctx: Ctx, template_id: int) -> B2VTemplate:
+    row = ctx.db.scalar(select(B2VTemplate).where(B2VTemplate.b2v_template_id == template_id,
+                                                  B2VTemplate.workspace_id == ctx.workspace.id))
+    if not row:
+        raise not_found("Template not found")
+    return row
+
+
+def owned_custom_voice(ctx: Ctx, custom_voice_id: int) -> B2VCustomVoice:
+    row = ctx.db.scalar(select(B2VCustomVoice).where(B2VCustomVoice.b2v_custom_voice_id == custom_voice_id,
+                                                     B2VCustomVoice.workspace_id == ctx.workspace.id))
+    if not row:
+        raise not_found("Voice not found")
+    return row
+
+
+def owned_style(ctx: Ctx, style_id: int) -> B2VStyle:
+    row = ctx.db.scalar(select(B2VStyle).where(B2VStyle.b2v_style_id == style_id,
+                                               B2VStyle.workspace_id == ctx.workspace.id))
+    if not row:
+        raise not_found("Style not found")
+    return row
+
+
+def _custom_id(ref: str, prefix: str) -> int | None:
+    raw = ref.removeprefix(prefix)
+    return int(raw) if ref.startswith(prefix) and raw.isdigit() else None
+
+
+def crafted_ids() -> set[str]:
+    out = set()
+    for t in b2v.crafted_templates():
+        tid = t.get("id") if isinstance(t, dict) else t
+        if isinstance(tid, str) and tid.startswith("crafted_"):
+            out.add(tid)
+    return out
+
+
+def check_template(ctx: Ctx, template: str, plan: Plan) -> None:
+    if template == "default":
+        return
+    if (cid := _custom_id(template, "custom_")) is not None:
+        row = owned_template(ctx, cid)
+        if not row.ready:
+            raise HTTPException(400, "That template is still being made.")
+        return
+    if template.startswith("crafted_"):
+        # blog2video silently falls back to "default" for an unknown id, so check it exists.
+        if template not in crafted_ids():
+            raise not_found("Template not found")
+        require_premium(ctx.db, ctx.workspace, "Designer templates", plan)
+        return
+    if template not in {t.get("id") for t in b2v.builtin_templates() if isinstance(t, dict)}:
+        raise not_found("Template not found")
+
+
+def check_style(ctx: Ctx, style: str) -> None:
+    if style in BUILTIN_STYLES:
+        return
+    if (sid := _custom_id(style, "custom:")) is not None:
+        owned_style(ctx, sid)
+        return
+    raise not_found("Video style not found")  # includes your_style, which learns from every workspace's edits
+
+
+def check_voice(ctx: Ctx, voice_id: str, plan: Plan) -> None:
+    """A built-in voice (premium if blog2video marks it paid) or one of this workspace's custom voices."""
+    prebuilt = {v.get("voice_id"): v for v in b2v.prebuilt_voices()}
+    if voice_id in prebuilt:
+        if prebuilt[voice_id].get("plan") == "paid":
+            require_premium(ctx.db, ctx.workspace, "This voice", plan)
+        return
+    if ctx.db.scalar(select(B2VCustomVoice).where(B2VCustomVoice.voice_id == voice_id,
+                                                  B2VCustomVoice.workspace_id == ctx.workspace.id)):
+        require_premium(ctx.db, ctx.workspace, "Custom voices", plan)
+        return
+    raise not_found("Voice not found")
+
+
+def check_refs(ctx: Ctx, body: dict, plan: Plan | None = None) -> Plan:
+    """Every id in a create or edit body must be this workspace's, and premium options need a paid plan."""
+    plan = plan or effective_plan(ctx.db, ctx.workspace)
+    if body.get("template"):
+        check_template(ctx, str(body["template"]), plan)
+    if body.get("video_style"):
+        check_style(ctx, str(body["video_style"]))
+    if body.get("custom_voice_id") and body.get("voice_gender") != "none":
+        check_voice(ctx, str(body["custom_voice_id"]), plan)
+    if str(body.get("video_length") or "") in PREMIUM_LENGTHS:
+        require_premium(ctx.db, ctx.workspace, "Longer videos", plan)
+    if body.get("voice_emotion"):
+        require_premium(ctx.db, ctx.workspace, "Advanced voice options", plan)
+    return plan
+
+
+# Catalog, filtered to what this workspace may see
+
+
+def visible_styles(ctx: Ctx) -> list[dict]:
+    """Built-in styles (read-only) and this workspace's custom styles. Never "Your Style", never others'."""
+    mine = set(ctx.db.scalars(select(B2VStyle.b2v_style_id).where(B2VStyle.workspace_id == ctx.workspace.id)))
+    out = []
+    for s in (b2v.video_styles() or {}).get("styles") or []:
+        if s.get("kind") == "builtin" and s.get("id") in BUILTIN_STYLES:
+            out.append({"id": s["id"], "name": s.get("name"), "description": s.get("description"), "kind": "builtin"})
+        elif s.get("kind") == "custom" and s.get("custom_id") in mine:
+            out.append({"id": s["id"], "custom_id": s["custom_id"], "name": s.get("name"),
+                        "description": s.get("description"), "guidance": s.get("guidance"),
+                        "version": s.get("version"), "kind": "custom"})
+    return out
+
+
+def my_templates(ctx: Ctx, ready_only: bool = False) -> list[B2VTemplate]:
+    q = select(B2VTemplate).where(B2VTemplate.workspace_id == ctx.workspace.id)
+    if ready_only:
+        q = q.where(B2VTemplate.ready.is_(True))
+    return list(ctx.db.scalars(q.order_by(B2VTemplate.created_at.desc())))

backend/app/services/billing.py

@@ -13,13 +13,14 @@ from app.config import settings
 from app.models import Artifact, CalendarItem, Notebook, Source, Subscription, User, VoiceProfile, Workspace
 from app.services.plans import PLANS, Plan, effective_plan, next_plan, plan_dict
 from app.services.usage import month_usage
+from app.services.video_quota import sync_video_quota, video_usage
 
 CYCLES = {"monthly", "annual"}
 LOW_FUEL = 0.8  # meters at or above this share of the allowance start nudging
 
 METERS = {
     "audio_minutes": ("Audio overviews", "min"),
-    "video_minutes": ("Video renders", "min"),
+    "videos": ("Videos", ""),
     "launch_kits": ("Launch Kits", ""),
 }
 
@@ -90,7 +91,7 @@ def build_nudges(db: Session, workspace: Workspace, plan: Plan, meters: list[dic
         left = "Unlimited" if kits["limit"] < 0 else f"{kits['limit']}"
         out.append(_nudge(f"act-kit-{month}", "action", "Launch your latest post",
                           f"{left} Launch Kits this month, none used yet. One click turns a post into threads, "
-                          "LinkedIn posts, quote cards and a short video.", "Build a Launch Kit",
+                          "LinkedIn posts and quote cards.", "Build a Launch Kit",
                           "/app/launch-kit", priority=70))
     elif kits["limit"] > 0 and kits["used"] < kits["limit"]:
         left = kits["limit"] - kits["used"]
@@ -119,6 +120,8 @@ def build_nudges(db: Session, workspace: Workspace, plan: Plan, meters: list[dic
 def billing_status(db: Session, workspace: Workspace) -> dict:
     plan = effective_plan(db, workspace)
     used = month_usage(db, workspace.id)
+    videos = video_usage(db, workspace)
+    used["videos"] = videos["used"]
     sources = _count(db, Source, workspace.id)
     meters = _meters(plan, used, sources)
     upgrade = next_plan(plan)
@@ -134,6 +137,7 @@ def billing_status(db: Session, workspace: Workspace) -> dict:
         "period_end": sub.current_period_end.isoformat() if sub and sub.current_period_end else None,
         "meters": meters,
         "since": used["since"],
+        "videos_resets_at": videos["resets_at"],
         "nudges": build_nudges(db, workspace, plan, meters, can_upgrade),
     }
 
@@ -156,6 +160,8 @@ def apply_subscription(db: Session, workspace_id, *, plan: str, status: str, pro
     sub.provider_subscription_id = subscription_id or sub.provider_subscription_id
     sub.current_period_end = current_period_end
     db.commit()
+    if workspace:
+        sync_video_quota(db, workspace)
     if workspace and effective_plan(db, workspace).indexed_posts != before:
         resync_sources(db, workspace_id)
     return sub

backend/app/services/blog2video.py

@@ -0,0 +1,326 @@
+"""blog2video: turns a post into an editable, narrated video. Every call goes through here.
+
+NoteStack is an ordinary blog2video API customer: each request carries our account's key
+(Authorization: Bearer b2v_live_...), and everything made with it (videos, custom templates, custom voices, video
+styles) belongs to that one account. blog2video does not know our workspaces and its ownership checks stop at the
+account, so callers must check ownership first (app/services/b2v_access.py) and charge the workspace's own
+allowances (app/services/video_quota.py, app/services/video_limits.py).
+
+Some endpoints change state shared by every workspace, or hand one workspace another's data. They are refused here,
+before anything is sent (DENIED). The key never reaches the browser or the logs.
+"""
+
+import logging
+import re
+import threading
+import time
+from collections.abc import Callable
+from typing import Any
+
+import httpx
+
+from app.config import settings
+
+log = logging.getLogger(__name__)
+
+STATUS_TIMEOUT = 30  # every call without its own timeout (status polls, edits): blog2video can take well over 10s
+UPLOAD_TIMEOUT = 120
+CREATE_ATTEMPTS = 3  # a create is retried with the same Idempotency-Key, which never makes a duplicate
+CATALOG_TTL = 3600
+
+# Account-wide endpoints NoteStack must never call (the integration guide, section 11).
+DENIED: list[tuple[str, re.Pattern]] = [
+    (m, re.compile(p)) for m, p in [
+        ("POST", r"^/api/projects/?$"),  # same URL within 10 minutes returns another workspace's project
+        ("POST", r"^/api/projects/bulk/?$"),
+        ("GET", r"^/api/projects/?$"),  # every project on the account
+        ("GET", r"^/api/projects/template-availability/?$"),
+        ("*", r"^/api/voices/saved(/.*)?$"),  # one saved-voice list shared by everyone
+        ("*", r"^/api/video-styles/builtin/.*$"),  # changes a built-in style for everyone
+        ("*", r"^/api/video-styles/pin/?$"),
+        ("*", r"^/api/video-styles/selection/?$"),
+        ("*", r"^/api/video-styles/your-style/?$"),
+        ("*", r"^/api/auth/me/script-preferences/?$"),
+    ]
+]
+
+
+class B2VError(RuntimeError):
+    def __init__(self, message: str, status: int = 502, detail: Any = None):
+        super().__init__(message)
+        self.status = status
+        self.detail = detail
+
+
+class AccountOutOfVideos(B2VError):
+    """Our blog2video account has no videos (or template slots) left. Not the user's fault; ops must buy more."""
+
+
+class NotFound(B2VError):
+    pass
+
+
+class Busy(B2VError):
+    """Another change is still running (409), or an account rate limit was hit (429)."""
+
+
+class TemplateInUse(B2VError):
+    """409 template_in_use: a video on the account still uses this custom template."""
+
+
+class BadRequest(B2VError):
+    pass
+
+
+class Upstream(B2VError):
+    """blog2video is down or slow, or rejected our key or plan (a configuration problem, not the user's)."""
+
+
+class Unreachable(Upstream):
+    """No answer at all (network error or timeout): a create may or may not have happened."""
+
+
+class Denied(B2VError):
+    """We refused to send this: the endpoint is account-wide (see DENIED)."""
+
+
+UNAVAILABLE = "Video creation is temporarily unavailable. Try again later."
+NOT_RESPONDING = "The video service is not responding. Try again in a minute."
+
+
+def configured() -> bool:
+    return bool(settings.b2v_api_base_url and settings.b2v_api_key)
+
+
+def _base() -> str:
+    return settings.b2v_api_base_url.rstrip("/")
+
+
+def denied(method: str, path: str) -> bool:
+    path = path.split("?", 1)[0]
+    return any(m in ("*", method.upper()) and p.match(path) for m, p in DENIED)
+
+
+def _body(resp: httpx.Response) -> Any:
+    try:
+        return resp.json()
+    except ValueError:
+        return resp.text[:500]
+
+
+def _error_code(body: Any) -> str | None:
+    """blog2video errors look like {"detail": {"error": "..."}} or {"detail": "..."}."""
+    if not isinstance(body, dict):
+        return None
+    detail = body.get("detail", body)
+    if isinstance(detail, dict):
+        return detail.get("error")
+    return detail if isinstance(detail, str) else None
+
+
+def _message(detail: Any, fallback: str) -> str:
+    if isinstance(detail, str) and detail.strip():
+        return detail.strip()[:300]
+    if isinstance(detail, dict) and isinstance(detail.get("message"), str):
+        return detail["message"][:300]
+    if isinstance(detail, list):  # 422s list the fields: [{"loc": [..., "url"], "msg": "..."}]
+        parts = [f"{(d.get('loc') or ['?'])[-1]}: {d.get('msg')}" for d in detail if isinstance(d, dict)]
+        if parts:
+            return "; ".join(parts)[:300]
+    return fallback
+
+
+def _raise_for(resp: httpx.Response, path: str) -> None:
+    if resp.status_code < 400:
+        return
+    body = _body(resp)
+    detail = body.get("detail", body) if isinstance(body, dict) else body
+    code = _error_code(body) or ""
+    status = resp.status_code
+    text = str(detail).lower()
+    if status == 402 or (status == 403 and "video limit reached" in text):
+        log.error("ALERT blog2video: our account is out of videos (%s): buy credits", path)
+        raise AccountOutOfVideos(UNAVAILABLE, 503, detail)
+    if status == 403 and code == "custom_template_limit":
+        log.error("ALERT blog2video: our account is out of custom template slots (%s): buy slots", path)
+        raise AccountOutOfVideos("Creating templates is temporarily unavailable. Try again later.", 503, detail)
+    if status == 401:
+        log.error("ALERT blog2video rejected our API key on %s (missing, revoked or rotated): update B2V_API_KEY",
+                  path)
+        raise Upstream(UNAVAILABLE, 503, detail)
+    if status == 403:
+        log.error("ALERT blog2video refused %s with 403 (%s): is the account still on a paid plan?", path,
+                  code or text[:120])
+        raise Upstream(UNAVAILABLE, 503, detail)
+    if 400 <= status < 500 and status not in (401, 403):
+        # What blog2video said, so a refused edit can be traced (never includes our key).
+        log.warning("blog2video %s -> %s: %s", path, status, str(detail)[:300])
+    if status == 404:
+        raise NotFound(_message(detail, "Not found"), 404, detail)
+    if status == 409 and code == "template_in_use":
+        raise TemplateInUse("A video still uses this template.", 409, detail)
+    if status == 409 or (status == 400 and "running" in text):
+        raise Busy(_message(detail, "Another change is still running, try again in a moment."), 409, detail)
+    if status == 429:
+        raise Busy(_message(detail, "The daily limit was reached. Try again later."), 429, detail)
+    if status in (400, 413, 415, 422):
+        raise BadRequest(_message(detail, str(code or "blog2video rejected the request")), 400, detail)
+    raise Upstream(NOT_RESPONDING, 502, detail)
+
+
+def _retry_after(resp: httpx.Response) -> float:
+    try:
+        return min(float(resp.headers.get("Retry-After", 1)), 5)
+    except ValueError:
+        return 1
+
+
+def request(method: str, path: str, *, json: Any = None, params: dict | None = None, data: dict | None = None,
+            files: Any = None, headers: dict | None = None, timeout: float | None = None,
+            raw: bool = False) -> Any:
+    """Call blog2video with our key. JSON by default; `data` + `files` send multipart; `raw` returns
+    (bytes, content_type) for audio and downloads. A POST with an Idempotency-Key (a create) is retried on no
+    answer, 5xx and 429, always with the same key: blog2video returns the original video, charged once."""
+    if denied(method, path):
+        log.error("refused to call account-wide blog2video endpoint %s %s", method, path)
+        raise Denied("Not available.", 404)
+    if not configured():
+        raise Upstream("Video is not set up yet.", 503)
+    url = f"{_base()}{path}"
+    timeout = timeout or STATUS_TIMEOUT
+    retryable = method == "POST" and bool(headers and headers.get("Idempotency-Key"))
+    attempts = CREATE_ATTEMPTS if retryable else 1
+    for attempt in range(1, attempts + 1):
+        last = attempt == attempts
+        started = time.monotonic()
+        try:
+            resp = httpx.request(method, url, json=json, params=params, data=data, files=files, timeout=timeout,
+                                 headers={**(headers or {}), "Authorization": f"Bearer {settings.b2v_api_key}"})
+        except httpx.HTTPError as e:
+            log.warning("blog2video %s %s failed (attempt %d): %s", method, path, attempt, type(e).__name__)
+            if last:
+                raise Unreachable(NOT_RESPONDING) from None
+            time.sleep(attempt)
+            continue
+        log.info("blog2video %s %s -> %s in %.0fms", method, path, resp.status_code,
+                 (time.monotonic() - started) * 1000)
+        if not last and (resp.status_code >= 500 or resp.status_code == 429):
+            time.sleep(_retry_after(resp) if resp.status_code == 429 else attempt)
+            continue
+        _raise_for(resp, path)
+        if raw:
+            return resp.content, resp.headers.get("content-type", "application/octet-stream")
+        return None if resp.status_code == 204 or not resp.content else _body(resp)
+    raise AssertionError("unreachable")
+
+
+# Shared catalog: the same for every workspace, cached for an hour.
+
+_cache: dict[str, tuple[float, Any]] = {}
+_cache_lock = threading.Lock()
+
+
+def cached(key: str, fetch: Callable[[], Any], ttl: float = CATALOG_TTL) -> Any:
+    with _cache_lock:
+        hit = _cache.get(key)
+        if hit and time.monotonic() - hit[0] < ttl:
+            return hit[1]
+    try:
+        value = fetch()
+    except B2VError:
+        if hit is None:
+            raise
+        # blog2video is slow or down: the last copy is better than failing the request.
+        log.warning("blog2video catalog %r could not be refreshed; using the copy from %.0fs ago",
+                    key, time.monotonic() - hit[0])
+        return hit[1]
+    with _cache_lock:
+        _cache[key] = (time.monotonic(), value)
+    return value
+
+
+def clear_cache() -> None:
+    with _cache_lock:
+        _cache.clear()
+
+
+def _catalog_timeout() -> float:
+    """Catalog lists are fetched about once an hour, so wait as long as a create would rather than fail."""
+    return settings.b2v_timeout_seconds
+
+
+def builtin_templates() -> list[dict]:
+    return cached("templates", lambda: request("GET", "/api/templates", timeout=_catalog_timeout()) or [])
+
+
+def crafted_templates() -> list[dict]:
+    return cached("crafted", lambda: request("GET", "/api/crafted-templates", timeout=_catalog_timeout()) or [])
+
+
+def prebuilt_voices() -> list[dict]:
+    """voice_id, name, preview_url, labels, description, plan ('free' | 'paid')."""
+    return cached("prebuilt", lambda: (request("GET", "/api/voices/prebuilt", timeout=_catalog_timeout()) or {})
+                  .get("voices") or [])
+
+
+def music_tracks() -> list[dict]:
+    """track_id, display_name, mood, r2_url."""
+    return cached("music", lambda: request("GET", "/api/background-music/tracks", timeout=_catalog_timeout()) or [])
+
+
+def video_styles() -> dict:
+    """Account-wide picker payload. Filter before use (b2v_access.visible_styles)."""
+    return request("GET", "/api/video-styles") or {}
+
+
+def account() -> Any:
+    """Our blog2video account: plan, videos, AI-edit allowance and credits, template slots."""
+    return request("GET", "/api/auth/me")
+
+
+# Videos
+
+def create_video(body: dict, idempotency_key: str) -> Any:
+    return request("POST", "/api/v1/videos", json=body, headers={"Idempotency-Key": idempotency_key},
+                   timeout=settings.b2v_timeout_seconds)
+
+
+def upload_project(form: dict, files: list[tuple[str, bytes, str]]) -> Any:
+    """Create a project from documents. Generation starts with generate()."""
+    return request("POST", "/api/projects/upload", data=form, timeout=UPLOAD_TIMEOUT,
+                   files=[("files", (name, content, ctype)) for name, content, ctype in files])
+
+
+def generate(project_id: int) -> Any:
+    return request("POST", f"/api/projects/{project_id}/generate", timeout=settings.b2v_timeout_seconds)
+
+
+def status(project_id: int, created_via: str = "v1") -> Any:
+    if created_via == "upload":
+        return request("GET", f"/api/projects/{project_id}/status")
+    return request("GET", f"/api/v1/videos/{project_id}/status")
+
+
+def get_project(project_id: int) -> Any:
+    """The whole project (scenes, assets). Much heavier than a status poll, so it gets the long timeout."""
+    return request("GET", f"/api/projects/{project_id}", timeout=settings.b2v_timeout_seconds)
+
+
+def delete_project(project_id: int) -> Any:
+    # blog2video removes the project's files before answering, which can take well over the 10s status timeout:
+    # timing out early reported a failure for a delete that went on to succeed.
+    return request("DELETE", f"/api/projects/{project_id}", timeout=settings.b2v_timeout_seconds)
+
+
+def upload_logo(project_id: int, filename: str, content_type: str, content: bytes) -> Any:
+    return request("POST", f"/api/projects/{project_id}/logo", files={"file": (filename, content, content_type)},
+                   timeout=UPLOAD_TIMEOUT)
+
+
+def preview_token(project_id: int) -> Any:
+    return request("POST", f"/api/embed/token/{project_id}")
+
+
+def project_call(method: str, project_id: int, sub: str, **kwargs) -> Any:
+    """Any /api/projects/{id}/... editor endpoint. Callers allowlist `sub` (app/routers/video_edit.py)."""
+    return request(method, f"/api/projects/{project_id}/{sub.lstrip('/')}", **kwargs)

backend/app/services/plans.py

@@ -1,12 +1,22 @@
-"""Three tiers. While BILLING_ENABLED is false every workspace gets Studio limits for free."""
+"""Plans live in the `plans` table (edit a row to change limits or prices; it takes effect within a minute).
+DEFAULT_PLANS below seeds that table and is used whenever it is empty or unreachable.
+While BILLING_ENABLED is false every workspace gets Studio limits for free."""
 
-from dataclasses import asdict, dataclass
+import logging
+import threading
+import time
+from collections.abc import Iterator, Mapping
+from dataclasses import asdict, dataclass, field
 
 from fastapi import HTTPException
+from sqlalchemy import select
+from sqlalchemy.exc import SQLAlchemyError
 from sqlalchemy.orm import Session
 
 from app.config import settings
-from app.models import Subscription, Workspace
+from app.models import PlanRecord, Subscription, Workspace
+
+log = logging.getLogger(__name__)
 
 ANNUAL_DISCOUNT = 0.25  # annual billing: 25% off the monthly price
 
@@ -20,14 +30,38 @@ class Plan:
     sources: int
     indexed_posts: int
     audio_minutes: int
-    video_minutes: int
+    videos: int  # blog2video videos per month, or in total when videos_monthly is False
     launch_kits: int  # -1 = unlimited
     voice_cloning: bool
     brand_kit: bool
     features: tuple[str, ...]
+    # Premium (★) video options: long durations, paid and custom voices, voice tuning and samples, AI script
+    # rewrites, AI chat editing, avatars, the Remotion source download.
+    video_premium: bool = False
+    # Per-workspace shares of what blog2video only limits account-wide (keys in VIDEO_LIMITS; 0 = none).
+    video_limits: dict = field(default_factory=dict)
+    videos_monthly: bool = True
+
+
+# metric -> period it counts over (app/services/video_limits.py)
+VIDEO_LIMITS = {
+    "ai_edits": "month",  # scene regenerate/add, AI images, stock clips, AI chat, template AI edits, avatars
+    "templates": "all",  # custom templates: blog2video's slots are lifetime, never given back
+    "template_ai_daily": "day",  # template theme extraction from a prompt or document, code generation
+    "voice_designs_daily": "day",
+    "voice_samples_daily": "day",
+    "custom_voices": "all",  # kept voices; deleting one frees its place
+}
 
+FREE_VIDEO_LIMITS = {"ai_edits": 20, "templates": 0, "template_ai_daily": 0, "voice_designs_daily": 0,
+                     "voice_samples_daily": 0, "custom_voices": 0}
+WRITER_VIDEO_LIMITS = {"ai_edits": 300, "templates": 2, "template_ai_daily": 3, "voice_designs_daily": 5,
+                       "voice_samples_daily": 20, "custom_voices": 3}
+STUDIO_VIDEO_LIMITS = {"ai_edits": 1000, "templates": 5, "template_ai_daily": 5, "voice_designs_daily": 10,
+                       "voice_samples_daily": 40, "custom_voices": 10}
 
-PLANS: dict[str, Plan] = {
+
+DEFAULT_PLANS: dict[str, Plan] = {
     "free": Plan(
         id="free",
         name="Free",
@@ -36,7 +70,7 @@ PLANS: dict[str, Plan] = {
         sources=1,
         indexed_posts=5,
         audio_minutes=3,
-        video_minutes=1,
+        videos=1,
         launch_kits=2,
         voice_cloning=False,
         brand_kit=False,
@@ -44,9 +78,11 @@ PLANS: dict[str, Plan] = {
             "1 source, your latest 5 posts indexed",
             "Grounded research chat with citations",
             "3 min of audio overviews a month",
-            "1 min of video a month",
+            "1 video to try it",
             "2 Launch Kits a month",
         ),
+        video_limits=FREE_VIDEO_LIMITS,
+        videos_monthly=False,
     ),
     "writer": Plan(
         id="writer",
@@ -56,18 +92,20 @@ PLANS: dict[str, Plan] = {
         sources=3,
         indexed_posts=500,
         audio_minutes=60,
-        video_minutes=30,
+        videos=10,
         launch_kits=50,
         voice_cloning=True,
         brand_kit=True,
         features=(
             "3 sources, 500 indexed posts",
             "60 min of audio overviews a month",
-            "30 min of video renders a month",
+            "10 videos a month",
             "50 Launch Kits a month",
             "Voice cloning with consent",
             "Your brand colors and logo",
         ),
+        video_premium=True,
+        video_limits=WRITER_VIDEO_LIMITS,
     ),
     "studio": Plan(
         id="studio",
@@ -77,22 +115,90 @@ PLANS: dict[str, Plan] = {
         sources=10,
         indexed_posts=5000,
         audio_minutes=240,
-        video_minutes=120,
+        videos=20,
         launch_kits=-1,
         voice_cloning=True,
         brand_kit=True,
         features=(
             "10 sources, 5,000 indexed posts",
             "240 min of audio overviews a month",
-            "120 min of video renders a month",
+            "20 videos a month",
             "Unlimited Launch Kits",
             "Launchpad calendar and resurfacing",
             "Priority rendering",
         ),
+        video_premium=True,
+        video_limits=STUDIO_VIDEO_LIMITS,
     ),
 }
 
 
+CACHE_SECONDS = 60
+
+
+def _plan_from_row(row: PlanRecord) -> Plan:
+    return Plan(id=row.id, name=row.name, tagline=row.tagline or "",
+                price_monthly_usd=float(row.price_monthly_usd or 0), sources=row.sources,
+                indexed_posts=row.indexed_posts, audio_minutes=row.audio_minutes,
+                videos=row.videos, launch_kits=row.launch_kits, voice_cloning=bool(row.voice_cloning),
+                brand_kit=bool(row.brand_kit), features=tuple(row.features or ()),
+                video_premium=bool(row.video_premium), videos_monthly=bool(row.videos_monthly),
+                video_limits={**{k: 0 for k in VIDEO_LIMITS}, **(row.video_limits or {})})
+
+
+def _read_table() -> dict[str, Plan] | None:
+    from app.db import SessionLocal
+
+    try:
+        with SessionLocal() as db:
+            rows = db.scalars(select(PlanRecord).order_by(PlanRecord.sort_order, PlanRecord.price_monthly_usd)).all()
+            plans = {r.id: _plan_from_row(r) for r in rows}
+    except SQLAlchemyError as e:
+        log.warning("plans table unreadable, using built-in plans: %s", type(e).__name__)
+        return None
+    if plans and "free" not in plans:
+        log.error("plans table has no 'free' row, using built-in plans")
+        return None
+    return plans or None
+
+
+class PlanCatalog(Mapping[str, Plan]):
+    """PLANS: the plans table, cheapest first, cached for CACHE_SECONDS."""
+
+    def __init__(self) -> None:
+        self._plans: dict[str, Plan] | None = None
+        self._loaded_at = 0.0
+        self._lock = threading.Lock()
+
+    def _current(self) -> dict[str, Plan]:
+        now = time.monotonic()
+        if self._plans is None or now - self._loaded_at >= CACHE_SECONDS:
+            with self._lock:
+                if self._plans is None or now - self._loaded_at >= CACHE_SECONDS:
+                    self._plans = _read_table() or DEFAULT_PLANS
+                    self._loaded_at = now
+        return self._plans
+
+    def reload(self) -> None:
+        """Drop the cache so the next read sees table edits immediately."""
+        self._plans = None
+
+    def order(self) -> list[str]:
+        return list(self._current())
+
+    def __getitem__(self, plan_id: str) -> Plan:
+        return self._current()[plan_id]
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self._current())
+
+    def __len__(self) -> int:
+        return len(self._current())
+
+
+PLANS = PlanCatalog()
+
+
 def to_99(amount: float) -> float:
     """Nearest price ending in .99 (18.74 -> 18.99, 36.74 -> 36.99)."""
     return 0.0 if amount <= 0 else round(max(0.99, round(amount + 0.01) - 0.01), 2)
@@ -130,28 +236,39 @@ def effective_plan(db: Session, workspace: Workspace) -> Plan:
     return PLANS.get(sub.plan, PLANS["free"])
 
 
-PLAN_ORDER = ["free", "writer", "studio"]
+def plan_order() -> list[str]:
+    return PLANS.order()
 
 
 def next_plan(plan: Plan) -> Plan | None:
-    i = PLAN_ORDER.index(plan.id)
-    return PLANS[PLAN_ORDER[i + 1]] if i + 1 < len(PLAN_ORDER) else None
+    order = plan_order()
+    i = order.index(plan.id)
+    return PLANS[order[i + 1]] if i + 1 < len(order) else None
 
 
 def upgrade_for(plan: Plan, kind: str | None = None) -> str | None:
     """Cheapest plan above this one that raises the limit named by kind (or simply the next tier)."""
-    for pid in PLAN_ORDER[PLAN_ORDER.index(plan.id) + 1:]:
+    order = plan_order()
+    for pid in order[order.index(plan.id) + 1:]:
         candidate = PLANS[pid]
         if kind is None:
             return pid
-        if kind == "voice_cloning" and candidate.voice_cloning:
-            return pid
-        current, better = getattr(plan, kind, 0), getattr(candidate, kind, 0)
-        if better < 0 or (isinstance(better, int | float) and better > current):
+        current, better = plan_value(plan, kind), plan_value(candidate, kind)
+        if isinstance(better, bool):
+            if better and not current:
+                return pid
+        elif isinstance(better, int | float) and (better < 0 or better > current):
             return pid
     return None
 
 
+def plan_value(plan: Plan, kind: str):
+    """A plan's limit or flag by name; "video_limits.<metric>" reads the per-metric video limits."""
+    if kind.startswith("video_limits."):
+        return plan.video_limits.get(kind.removeprefix("video_limits."), 0)
+    return getattr(plan, kind, 0)
+
+
 def plan_limit_error(plan: Plan, kind: str, message: str) -> HTTPException:
     """402 the frontend turns into the out of fuel popup."""
     return HTTPException(402, {"code": "plan_limit", "message": message, "kind": kind,

backend/app/services/renderer.py

@@ -7,8 +7,6 @@ from app.models import Artifact, Job
 from app.services.storage import keys, storage
 
 COMPOSITIONS = {
-    "ShortVertical": "mp4",
-    "ExplainerLong": "mp4",
     "AudiogramSquare": "mp4",
     "QuoteCard": "png",
     "CarouselSlide": "png",

backend/app/services/stripe_billing.py

@@ -30,6 +30,7 @@ from sqlalchemy.orm import Session
 
 from app.config import settings
 from app.models import BillingEvent, Subscription, User, Workspace
+from app.services import video_quota
 from app.services.plans import PLANS, Plan, annual_prices
 
 log = logging.getLogger(__name__)
@@ -150,6 +151,9 @@ def sync_subscription(db: Session, workspace_id: uuid.UUID, stripe_sub) -> Subsc
     sub.plan = plan_id if (plan_id in PLANS and status in LIVE) else "free"
     sub.current_period_end = _ts(period_end)
     db.commit()
+    workspace = db.get(Workspace, workspace_id)
+    if workspace:
+        video_quota.sync_video_quota(db, workspace)
     return sub
 
 
@@ -336,6 +340,11 @@ def handle_event(db: Session, event) -> str:
         ws = _workspace_for(db, stripe_sub, customer_id=_get(obj, "customer"))
         if ws and stripe_sub is not None:
             sync_subscription(db, ws, stripe_sub)
+        # A new billing period (or a new paid plan) starts a fresh video allowance. `first` keeps a retried
+        # delivery of the same event from wiping videos made since.
+        if first and ws and kind == "invoice.paid" and \
+                _get(obj, "billing_reason") in {"subscription_cycle", "subscription_create"}:
+            video_quota.reset_videos(db, ws)
         if first and kind in {"invoice.payment_action_required", "invoice.payment_failed"}:
             # The first invoice of a Checkout is handled on the Checkout page itself.
             if _get(obj, "billing_reason") != "subscription_create":

backend/app/services/usage.py

@@ -7,6 +7,7 @@ from sqlalchemy.orm import Session
 
 from app.models import Artifact, UsageEvent, Workspace
 from app.services.plans import Plan, effective_plan, plan_limit_error
+from app.services.video_quota import video_usage
 
 
 def month_start(now: datetime | None = None) -> datetime:
@@ -32,7 +33,6 @@ def month_usage(db: Session, workspace_id) -> dict:
     ) or 0
     return {
         "audio_minutes": round(total("tts", "seconds") / 60, 1),
-        "video_minutes": round(total("video", "seconds") / 60, 1),
         "launch_kits": kits,
         "llm_tokens": int(total("llm", "tokens")),
         "since": since.isoformat(),
@@ -42,10 +42,13 @@ def month_usage(db: Session, workspace_id) -> dict:
 def usage_report(db: Session, workspace: Workspace) -> dict:
     plan = effective_plan(db, workspace)
     used = month_usage(db, workspace.id)
+    videos = video_usage(db, workspace)
+    used["videos"] = videos["used"]
     return {
         "plan": plan.id,
         "used": used,
-        "limits": {"audio_minutes": plan.audio_minutes, "video_minutes": plan.video_minutes,
+        "videos_resets_at": videos["resets_at"],
+        "limits": {"audio_minutes": plan.audio_minutes, "videos": videos["limit"],
                    "launch_kits": plan.launch_kits, "sources": plan.sources, "indexed_posts": plan.indexed_posts},
     }
 
@@ -54,8 +57,7 @@ def check_limit(db: Session, workspace: Workspace, kind: str, amount: float = 1)
     """Raise 402 plan_limit when this request would go over the monthly allowance."""
     plan = effective_plan(db, workspace)
     used = month_usage(db, workspace.id)
-    limit = {"audio_minutes": plan.audio_minutes, "video_minutes": plan.video_minutes,
-             "launch_kits": plan.launch_kits}[kind]
+    limit = {"audio_minutes": plan.audio_minutes, "launch_kits": plan.launch_kits}[kind]
     if limit >= 0 and used[kind] + amount > limit:
         label = kind.replace("_", " ")
         raise plan_limit_error(plan, kind, f"This would go over your {limit} {label} this month.")

backend/app/services/video_limits.py

@@ -0,0 +1,93 @@
+"""Per-workspace shares of what blog2video only limits account-wide: AI edits, custom templates, template AI
+operations, voice designs, voice samples, custom voices (plans.VIDEO_LIMITS), plus premium (★) video options.
+
+blog2video checks every limit against our own (Pro) account, so every workspace passes its checks. These counters
+stop a workspace before it uses up everyone's share. Videos themselves are counted in video_quota.py.
+
+A take is one conditional UPDATE (used + n <= limit), so two requests can not both take the last unit.
+"""
+
+import uuid
+from datetime import UTC, datetime
+
+from sqlalchemy import case, select, update
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.orm import Session
+
+from app.models import UsageCounter, Workspace
+from app.services.plans import VIDEO_LIMITS, Plan, effective_plan, plan_limit_error
+
+LABELS = {
+    "ai_edits": ("AI edits", "this month"),
+    "templates": ("custom templates", "in total"),
+    "template_ai_daily": ("AI template steps", "today"),
+    "voice_designs_daily": ("voice designs", "today"),
+    "voice_samples_daily": ("voice samples", "today"),
+    "custom_voices": ("custom voices", "at a time"),
+}
+
+
+def period_key(metric: str, now: datetime | None = None) -> str:
+    now = now or datetime.now(UTC)
+    kind = VIDEO_LIMITS[metric]
+    return now.strftime("%Y-%m-%d") if kind == "day" else now.strftime("%Y-%m") if kind == "month" else "all"
+
+
+def _ensure_row(db: Session, workspace_id: uuid.UUID, period: str, metric: str) -> None:
+    key = {"workspace_id": workspace_id, "period": period, "metric": metric}
+    if db.get(UsageCounter, key) is not None:
+        return
+    db.add(UsageCounter(**key, used=0))
+    try:
+        db.commit()
+    except IntegrityError:  # a concurrent request made it first
+        db.rollback()
+
+
+def used(db: Session, workspace_id: uuid.UUID, metric: str) -> int:
+    row = db.get(UsageCounter, {"workspace_id": workspace_id, "period": period_key(metric), "metric": metric})
+    return row.used if row else 0
+
+
+def take(db: Session, workspace: Workspace, metric: str, n: int = 1, plan: Plan | None = None) -> None:
+    """Use n units of metric, or raise the 402 that opens the upgrade popup."""
+    plan = plan or effective_plan(db, workspace)
+    limit = int(plan.video_limits.get(metric, 0))
+    period = period_key(metric)
+    _ensure_row(db, workspace.id, period, metric)
+    where = [UsageCounter.workspace_id == workspace.id, UsageCounter.period == period, UsageCounter.metric == metric]
+    if limit >= 0:  # -1 = unlimited, still counted
+        where.append(UsageCounter.used + n <= limit)
+    taken = db.execute(update(UsageCounter).where(*where).values(used=UsageCounter.used + n)).rowcount
+    db.commit()
+    if taken != 1:
+        label, when = LABELS[metric]
+        message = (f"Your plan does not include {label}." if limit == 0
+                   else f"You have used all {limit} {label} {when}.")
+        raise plan_limit_error(plan, f"video_limits.{metric}", message)
+
+
+def give_back(db: Session, workspace_id: uuid.UUID, metric: str, n: int = 1) -> None:
+    """Undo a take whose blog2video call failed (or a custom voice that was deleted)."""
+    db.execute(update(UsageCounter)
+               .where(UsageCounter.workspace_id == workspace_id, UsageCounter.period == period_key(metric),
+                      UsageCounter.metric == metric)
+               .values(used=case((UsageCounter.used > n, UsageCounter.used - n), else_=0)))
+    db.commit()
+
+
+def require_premium(db: Session, workspace: Workspace, what: str, plan: Plan | None = None) -> Plan:
+    plan = plan or effective_plan(db, workspace)
+    if not plan.video_premium:
+        raise plan_limit_error(plan, "video_premium", f"{what} comes with a paid plan.")
+    return plan
+
+
+def report(db: Session, workspace: Workspace) -> dict:
+    """What the wizard shows: premium or not, and each counter's used / limit."""
+    plan = effective_plan(db, workspace)
+    rows = {(r.period, r.metric): r.used for r in db.scalars(
+        select(UsageCounter).where(UsageCounter.workspace_id == workspace.id))}
+    return {"premium": plan.video_premium,
+            "limits": {m: {"used": rows.get((period_key(m), m), 0), "limit": int(plan.video_limits.get(m, 0))}
+                       for m in VIDEO_LIMITS}}

backend/app/services/video_quota.py

@@ -0,0 +1,239 @@
+"""Video allowance, kept on the workspace's subscriptions row and enforced only by us.
+
+blog2video charges every video to our own account; it does not know our workspaces. So we:
+- reserve one video (videos_used + 1, only while below video_limit) before asking blog2video for it;
+- refund it exactly once if the create is refused or generation fails (the b2v_videos row records which);
+- keep video_plan and video_limit equal to the effective plan, and set videos_used back to 0 each month on plans
+  with a monthly allowance: on Stripe renewal (invoice.paid, see stripe_billing.handle_event), and monthly for
+  workspaces with no renewal to wait for (billing disabled, annual plans between renewals).
+- Free's allowance is a lifetime total (plan.videos_monthly False): never reset. When a workspace drops to such a
+  plan, videos_used becomes its lifetime count of videos that were not refunded.
+
+videos_used is only ever written with a single SQL UPDATE here, never through the ORM, so a sync can not
+overwrite a concurrent reserve or refund.
+"""
+
+import calendar
+import logging
+import uuid
+from collections.abc import Callable
+from datetime import UTC, datetime, timedelta
+
+from sqlalchemy import case, func, select, update
+from sqlalchemy.orm import Session
+
+from app.config import settings
+from app.db import SessionLocal
+from app.models import Artifact, B2VVideo, Subscription, Workspace
+from app.services import blog2video as b2v
+from app.services.plans import PLANS, effective_plan
+
+log = logging.getLogger(__name__)
+
+LIVE = {"active", "trialing", "past_due"}
+RENEWAL_WINDOW = timedelta(days=45)  # a Stripe renewal this close to the period start does the reset instead
+FAILED = {"failed", "error"}
+FINISHED = {"generated", "done"}
+SWEEP_AFTER = timedelta(minutes=30)  # the sweep only looks at videos older than this (users who closed the tab)
+
+
+def add_month(when: datetime) -> datetime:
+    year, month = (when.year + 1, 1) if when.month == 12 else (when.year, when.month + 1)
+    return when.replace(year=year, month=month, day=min(when.day, calendar.monthrange(year, month)[1]))
+
+
+def _aware(when: datetime | None) -> datetime | None:
+    return when.replace(tzinfo=UTC) if when and when.tzinfo is None else when
+
+
+def _row(db: Session, workspace_id: uuid.UUID) -> Subscription:
+    sub = db.scalar(select(Subscription).where(Subscription.workspace_id == workspace_id))
+    if not sub:
+        sub = Subscription(workspace_id=workspace_id, plan="free", status="active")
+        db.add(sub)
+        db.flush()
+    return sub
+
+
+def sync_video_quota(db: Session, workspace: Workspace) -> Subscription:
+    """Make video_plan and video_limit match the workspace's effective plan. Cheap when nothing changed."""
+    plan = effective_plan(db, workspace)
+    sub = _row(db, workspace.id)
+    changed = False
+    if sub.video_plan != plan.id and not plan.videos_monthly:
+        # Onto a lifetime allowance: everything made so far counts (a Writer who made 10 can't make more on Free).
+        made = db.scalar(select(func.count(B2VVideo.id)).where(B2VVideo.workspace_id == workspace.id,
+                                                               B2VVideo.quota_state != "refunded")) or 0
+        db.execute(update(Subscription).where(Subscription.id == sub.id).values(videos_used=made))
+        changed = True
+    if sub.video_plan != plan.id or sub.video_limit != plan.videos:
+        sub.video_plan, sub.video_limit = plan.id, plan.videos
+        changed = True
+    if sub.videos_period_start is None:
+        sub.videos_period_start = datetime.now(UTC)
+        changed = True
+    if changed:
+        db.commit()
+    return sub
+
+
+def _renews_by_stripe(sub: Subscription) -> bool:
+    start, end = _aware(sub.videos_period_start), _aware(sub.current_period_end)
+    return bool(sub.provider_subscription_id and sub.status in LIVE and start and end
+                and end <= start + RENEWAL_WINDOW)
+
+
+def monthly(sub: Subscription) -> bool:
+    plan = PLANS.get(sub.video_plan)
+    return plan.videos_monthly if plan else True
+
+
+def resets_at(sub: Subscription) -> datetime | None:
+    start = _aware(sub.videos_period_start)
+    if not start or not monthly(sub):
+        return None
+    return _aware(sub.current_period_end) if _renews_by_stripe(sub) else add_month(start)
+
+
+def video_usage(db: Session, workspace: Workspace) -> dict:
+    sub = sync_video_quota(db, workspace)
+    db.refresh(sub)  # videos_used changes under us (reserves and refunds from other requests)
+    reset = resets_at(sub)
+    start = _aware(sub.videos_period_start)
+    return {"used": sub.videos_used, "limit": sub.video_limit, "plan": sub.video_plan,
+            "period_start": start.isoformat() if start else None, "resets_at": reset.isoformat() if reset else None}
+
+
+def reset_videos(db: Session, workspace_id: uuid.UUID, at: datetime | None = None) -> None:
+    db.execute(update(Subscription).where(Subscription.workspace_id == workspace_id)
+               .values(videos_used=0, videos_period_start=at or datetime.now(UTC)))
+    db.commit()
+
+
+def reset_due_video_periods(session_factory: Callable[[], Session] = SessionLocal) -> int:
+    """Monthly reset for workspaces a Stripe renewal will not reset in time. Runs from the worker's PERIODIC list."""
+    now = datetime.now(UTC)
+    count = 0
+    with session_factory() as db:
+        for sub in db.scalars(select(Subscription)):
+            start = _aware(sub.videos_period_start)
+            if start is None or _renews_by_stripe(sub) or not monthly(sub):
+                continue
+            if add_month(start) <= now:
+                reset_videos(db, sub.workspace_id, now)
+                count += 1
+    return count
+
+
+def reserve(db: Session, workspace_id: uuid.UUID) -> bool:
+    """Take one video from the allowance, atomically: two requests can not both take the last one.
+    False = none left (do not call blog2video)."""
+    taken = db.execute(update(Subscription)
+                       .where(Subscription.workspace_id == workspace_id,
+                              Subscription.videos_used < Subscription.video_limit)
+                       .values(videos_used=Subscription.videos_used + 1)).rowcount
+    db.commit()
+    return taken == 1
+
+
+def unreserve(db: Session, workspace_id: uuid.UUID) -> None:
+    """Give back a reservation that never got a b2v_videos row."""
+    db.execute(update(Subscription).where(Subscription.workspace_id == workspace_id)
+               .values(videos_used=case((Subscription.videos_used > 0, Subscription.videos_used - 1), else_=0)))
+    db.commit()
+
+
+def refund(db: Session, row: B2VVideo, status: str | None = None) -> bool:
+    """Give the workspace its video back, exactly once per row, however many callers race here, and never once
+    it finished generating ('kept'). True if this call did the refund."""
+    values = {"quota_state": "refunded", "updated_at": datetime.now(UTC)}
+    if status:
+        values["status"] = status
+    won = db.execute(update(B2VVideo).where(B2VVideo.id == row.id, B2VVideo.quota_state == "charged")
+                     .values(**values)).rowcount == 1
+    if won:
+        db.execute(update(Subscription).where(Subscription.workspace_id == row.workspace_id)
+                   .values(videos_used=case((Subscription.videos_used > 0, Subscription.videos_used - 1),
+                                            else_=0)))
+    db.commit()
+    db.refresh(row)
+    return won
+
+
+def record_status(db: Session, row: B2VVideo, status: str) -> None:
+    """Remember blog2video's latest status, refunding when it says the video failed. Once generation finished the
+    charge is kept (quota_state 'kept'): a later failed edit does not give the video back."""
+    if status in FAILED:
+        refund(db, row, "failed")
+    elif status and row.status != status:
+        values = {"status": status, "updated_at": datetime.now(UTC)}
+        if status in FINISHED:
+            values["quota_state"] = case((B2VVideo.quota_state == "charged", "kept"), else_=B2VVideo.quota_state)
+        db.execute(update(B2VVideo).where(B2VVideo.id == row.id).values(**values))
+        db.commit()
+        db.refresh(row)
+
+
+def sweep_failed_videos(session_factory: Callable[[], Session] = SessionLocal) -> int:
+    """Refund videos that failed while nobody was polling (the user closed the tab). Runs from PERIODIC."""
+    if not b2v.configured():
+        return 0
+    cutoff = datetime.now(UTC) - SWEEP_AFTER
+    refunded = 0
+    with session_factory() as db:
+        rows = db.scalars(select(B2VVideo).where(B2VVideo.quota_state == "charged",
+                                                 B2VVideo.status.not_in(FINISHED),
+                                                 B2VVideo.created_at < cutoff)).all()
+        for row in rows:
+            if row.b2v_video_id is None:
+                # The create never got an answer and the request died before refunding.
+                refunded += refund(db, row, "failed")
+                continue
+            try:
+                s = b2v.status(row.b2v_video_id, row.created_via)
+            except b2v.NotFound:
+                s = {"status": "failed", "error": "Video not found"}
+            except b2v.B2VError as e:
+                log.warning("video sweep: status of %s failed: %s", row.b2v_video_id, e)
+                continue
+            raw = str(s.get("status") or "")
+            if s.get("error") and raw not in FAILED:
+                raw = "failed"
+            if raw in FAILED:
+                refunded += refund(db, row, "failed")
+                if row.artifact_id and (a := db.get(Artifact, row.artifact_id)):
+                    a.status = "failed"
+                    a.content_json = {**(a.content_json or {}), "b2v_status": raw, "error": s.get("error")}
+                    db.commit()
+            elif raw:
+                record_status(db, row, raw)
+    return refunded
+
+
+AI_EDITS_ALERT_BELOW = 200
+TEMPLATE_SLOTS_ALERT_BELOW = 3
+
+
+def check_capacity() -> dict | None:
+    """Alert when our blog2video account runs low: our workspaces' limits added up can exceed it. Hourly."""
+    if not b2v.configured():
+        return None
+    try:
+        account = b2v.account() or {}
+    except b2v.B2VError as e:
+        log.error("ALERT blog2video capacity check failed: %s", e)
+        return None
+    low = []
+    limit, used = account.get("video_limit"), account.get("videos_used_this_period")
+    if not account.get("can_create_video") or (
+            limit is not None and used is not None and limit - used < settings.b2v_capacity_alert_below):
+        low.append(f"videos {used}/{limit} used")
+    ai = (account.get("ai_edit_allowance_remaining") or 0) + (account.get("ai_edit_credits") or 0)
+    if ai < AI_EDITS_ALERT_BELOW:
+        low.append(f"{ai} AI edits left")
+    slots, made = account.get("custom_template_limit"), account.get("custom_templates_created")
+    if slots is not None and made is not None and slots - made < TEMPLATE_SLOTS_ALERT_BELOW:
+        low.append(f"template slots {made}/{slots} used")
+    if low:
+        log.error("ALERT blog2video account (plan %s) is running low: %s", account.get("plan"), "; ".join(low))
+    return account

backend/app/worker.py

@@ -44,7 +44,7 @@ from app.models import (
 from app.pipeline import generate, launchkit, media
 from app.pipeline.generate import NothingToDo
 from app.pipeline.ingest import FeedNotFound, entry_from_upload, extract_article, ingest_source, store_entries
-from app.services import launchpad, tts
+from app.services import launchpad, tts, video_quota
 from app.services.email import email_service
 from app.services.email_verification import purge_old_codes
 from app.services.jobs import claim_next, create_job, record_usage, retry_or_fail, stale_jobs, update_job
@@ -226,7 +226,7 @@ HANDLERS: dict[str, Callable[[Session, Job], object]] = {
     "resurface_scan": handle_resurface,
     "summary": _artifact_handler(generate.summarize_notebook, "Summary ready"),
     "audio_overview": _artifact_handler(media.audio_overview, "Audio overview ready"),
-    "video": _artifact_handler(media.make_video, "Video ready"),
+    "video": _artifact_handler(media.make_video, "Audiogram ready"),  # audiograms; videos come from blog2video
     "quote_card": _artifact_handler(media.make_quote_card, "Quote card ready"),
     "carousel": _artifact_handler(media.render_carousel, "Carousel ready"),
     "launch_kit": _artifact_handler(launchkit.build_launch_kit, "Launch Kit ready"),
@@ -364,6 +364,9 @@ PERIODIC = [
     Periodic("sync_engagement", 3600, launchpad.sync_engagement),
     Periodic("update_email_batch", 300, update_email_batch),
     Periodic("daily_cleanup", 24 * 3600, daily_cleanup),
+    Periodic("video_period_reset", 3600, video_quota.reset_due_video_periods),
+    Periodic("video_refund_sweep", 600, video_quota.sweep_failed_videos),
+    Periodic("video_capacity_check", 3600, video_quota.check_capacity),
 ]
 
 

backend/requirements.txt

@@ -13,6 +13,7 @@ requests==2.*
 boto3==1.35.*
 resend==2.*
 httpx==0.28.*
+python-multipart==0.0.*
 dspy==2.6.*
 feedparser==6.*
 beautifulsoup4==4.*

backend/tests/conftest.py

@@ -11,6 +11,8 @@ os.environ["ELEVENLABS_API_KEY"] = ""
 os.environ["FIRECRAWL_API_KEY"] = ""
 os.environ["R2_PREFIX"] = ""
 os.environ["TYPESAFE_API_KEY"] = ""
+os.environ["B2V_API_BASE_URL"] = ""
+os.environ["B2V_API_KEY"] = ""
 os.environ.setdefault("EMAIL_PROVIDER", "console")
 os.environ.setdefault("JWT_SECRET", "test-secret-that-is-at-least-32-bytes-long")
 os.environ.setdefault("BILLING_ENABLED", "false")

backend/tests/test_billing.py

@@ -23,7 +23,7 @@ def billing_on(monkeypatch):
 def test_status_without_billing_has_no_upgrade_nudges(client, auth):
     body = client.get("/api/billing/status", headers=auth).json()
     assert body["plan"]["id"] == "studio" and body["can_upgrade"] is False
-    assert {m["key"] for m in body["meters"]} == {"audio_minutes", "video_minutes", "launch_kits", "sources"}
+    assert {m["key"] for m in body["meters"]} == {"audio_minutes", "videos", "launch_kits", "sources"}
     assert all(n["tone"] == "action" for n in body["nudges"])
     assert body["nudges"][0]["id"] == "act-source"
 
@@ -76,3 +76,69 @@ def test_plan_limit_error_names_the_upgrade():
     assert upgrade_for(PLANS["studio"], "audio_minutes") is None
     detail = plan_limit_error(PLANS["free"], "audio_minutes", "x").detail
     assert detail["code"] == "plan_limit" and detail["upgrade_to"] == "writer" and detail["kind"] == "audio_minutes"
+
+
+@pytest.fixture()
+def plans_table(monkeypatch):
+    """Point the plan catalog at its own database, seeded like migration 0006. (Not the client's: that one
+    shares a single connection, and the catalog's own session would roll back the request's work.)"""
+    from sqlalchemy import create_engine
+    from sqlalchemy.orm import sessionmaker
+    from sqlalchemy.pool import StaticPool
+
+    import app.db
+    from app.db import Base
+    from app.models import PlanRecord
+    from app.services.plans import DEFAULT_PLANS, PLANS
+
+    engine = create_engine("sqlite://", connect_args={"check_same_thread": False}, poolclass=StaticPool)
+    Base.metadata.create_all(engine)
+    session_factory = sessionmaker(bind=engine, expire_on_commit=False)
+    monkeypatch.setattr(app.db, "SessionLocal", session_factory)
+    with session_factory() as db:
+        for i, p in enumerate(DEFAULT_PLANS.values()):
+            db.add(PlanRecord(id=p.id, sort_order=i, name=p.name, tagline=p.tagline,
+                              price_monthly_usd=p.price_monthly_usd, sources=p.sources, indexed_posts=p.indexed_posts,
+                              audio_minutes=p.audio_minutes, videos=p.videos, launch_kits=p.launch_kits,
+                              voice_cloning=p.voice_cloning, brand_kit=p.brand_kit, features=list(p.features)))
+        db.commit()
+    PLANS.reload()
+    yield session_factory
+    PLANS.reload()
+
+
+def test_plans_come_from_the_table(plans_table):
+    from app.models import PlanRecord
+    from app.services.plans import PLANS, next_plan
+
+    with plans_table() as db:
+        db.get(PlanRecord, "studio").videos = 50
+        db.get(PlanRecord, "writer").features = ["Edited copy"]
+        db.commit()
+    PLANS.reload()
+    assert PLANS["studio"].videos == 50 and PLANS["writer"].features == ("Edited copy",)
+    assert list(PLANS) == ["free", "writer", "studio"] and next_plan(PLANS["free"]).id == "writer"
+
+
+def test_edited_limit_reaches_video_quota(plans_table, client, auth, db_session):
+    from app.models import PlanRecord, Workspace
+    from app.services.plans import PLANS
+    from app.services.video_quota import sync_video_quota
+
+    with plans_table() as db:
+        db.get(PlanRecord, "studio").videos = 42  # billing disabled: everyone is on Studio
+        db.commit()
+    PLANS.reload()
+    ws = db_session.query(Workspace).one()
+    assert sync_video_quota(db_session, ws).video_limit == 42
+
+
+def test_empty_or_broken_table_falls_back_to_defaults(plans_table):
+    from app.models import PlanRecord
+    from app.services.plans import DEFAULT_PLANS, PLANS
+
+    with plans_table() as db:
+        db.query(PlanRecord).filter(PlanRecord.id == "free").delete()  # no free plan: unusable
+        db.commit()
+    PLANS.reload()
+    assert PLANS["free"] == DEFAULT_PLANS["free"] and PLANS["studio"].videos == DEFAULT_PLANS["studio"].videos

backend/tests/test_buildout.py

@@ -404,26 +404,32 @@ def test_audio_overview_and_limits(client, auth, run_jobs, feed, llm, monkeypatc
     assert r.status_code == 402 and r.json()["detail"]["code"] == "plan_limit"
 
 
-def test_video_hands_off_and_renderer_callback(client, auth, run_jobs, feed, llm, monkeypatch):
-    from app.pipeline import media
-
+def test_native_video_moved_to_blog2video(client, auth, run_jobs, feed):
     connect(client, auth, run_jobs)
     doc = docs(client, auth)[0]
+    r = client.post("/api/artifacts/generate", json={"type": "video", "document_id": doc["id"], "style": "short"},
+                    headers=auth)
+    assert r.status_code == 410
+
+
+def test_audiogram_hands_off_and_renderer_callback(client, auth, monkeypatch, db_session, run_jobs):
+    from app.config import settings
+    from app.models import Artifact, Workspace
+    from app.pipeline import media
+
+    ws = db_session.query(Workspace).one()
+    audio = Artifact(workspace_id=ws.id, type="audio_overview", status="ready", storage_key="ws/x/audio.mp3",
+                     content_json={"title": "Pricing", "duration_s": 42, "segments": []})
+    db_session.add(audio)
+    db_session.commit()
     sent = {}
     monkeypatch.setattr(media, "request_render", lambda job, artifact, comp, props=None, stills=None:
                         sent.update(comp=comp, props=props, job=str(job.id)))
-    llm["VideoStoryboard"] = {"scenes": [
-        {"type": "title", "on_screen_text": "Charge more", "narration": "", "duration_hint_s": 2.5, "visual": ""},
-        {"type": "section", "on_screen_text": "Readers valued it", "narration": "", "duration_hint_s": 3,
-         "visual": ""},
-    ]}
-    art = client.post("/api/artifacts/generate", json={"type": "video", "document_id": doc["id"], "style": "short"},
-                      headers=auth).json()
+    art = client.post("/api/artifacts/generate", json={"type": "video", "style": "audiogram",
+                                                       "audio_artifact_id": str(audio.id)}, headers=auth).json()
     job = run_jobs()[0]
     assert job.status == "running"  # handed off to the renderer
-    assert sent["comp"] == "ShortVertical" and sent["props"]["hook"] == "Charge more"
-    from app.config import settings
-
+    assert sent["comp"] == "AudiogramSquare"
     r = client.post(f"/api/internal/jobs/{sent['job']}/progress", headers={"x-internal-token": settings.internal_token},
                     json={"status": "done", "progress": 1, "storage_key": "ws/x/video.mp4", "render_seconds": 12})
     assert r.status_code == 200

backend/tests/test_simplified_flows.py

@@ -1,9 +1,11 @@
 """One-click flows: the "All posts" notebook, whole-archive generation, and jobs that run after a sync."""
 
+import pytest
 from sqlalchemy import select
+from sqlalchemy.exc import IntegrityError
 
 from app.config import settings
-from app.models import Job
+from app.models import Job, Notebook, Workspace
 from tests.test_buildout import auth, connect, docs, feed, llm  # noqa: F401  (fixtures)
 
 
@@ -23,6 +25,17 @@ def test_archive_notebook_is_created_once_and_listed_first(client, auth, run_job
     assert nb["is_archive"] and len(nb["documents"]) == len(indexed)
 
 
+def test_a_workspace_cannot_have_two_archive_notebooks(client, auth, db_session):  # noqa: F811
+    client.post("/api/notebooks/archive", headers=auth)
+    ws = db_session.scalar(select(Workspace))
+    db_session.add(Notebook(workspace_id=ws.id, title="All posts", is_archive=True))
+    with pytest.raises(IntegrityError):
+        db_session.commit()
+    db_session.rollback()
+    db_session.add(Notebook(workspace_id=ws.id, title="Mine"))  # ordinary notebooks are not limited
+    db_session.commit()
+
+
 def test_generate_from_whole_archive_uses_the_archive_notebook(client, auth, run_jobs, feed):  # noqa: F811
     connect(client, auth, run_jobs)
     art = client.post("/api/artifacts/generate", json={"type": "summary", "archive": True}, headers=auth).json()

backend/tests/test_stripe_billing.py

@@ -199,3 +199,37 @@ def test_upgrade_needing_3ds_sends_user_to_invoice(client, stripe_on, owner, db_
     r = client.post("/api/billing/checkout", json={"plan": "studio", "cycle": "monthly"}, headers=headers)
     assert r.json()["url"] == "https://invoice.stripe.test/i_1"
     assert plan_of(db_session, ws) == "writer"  # switches only once the payment succeeds
+
+
+def videos_used(db, ws) -> int:
+    db.expire_all()
+    return db.scalar(select(Subscription).where(Subscription.workspace_id == ws.id)).videos_used
+
+
+def set_videos_used(db, ws, n: int) -> None:
+    db.scalar(select(Subscription).where(Subscription.workspace_id == ws.id)).videos_used = n
+    db.commit()
+
+
+@pytest.mark.parametrize("reason,resets", [("subscription_cycle", True), ("subscription_create", True),
+                                           ("subscription_update", False)])
+def test_invoice_paid_resets_videos(client, stripe_on, owner, db_session, reason, resets):
+    _, ws = owner
+    stripe_on.add_sub("sub_v", ws.id, plan="writer")
+    set_videos_used(db_session, ws, 7)
+    paid = event("invoice.paid", {"subscription": "sub_v", "customer": "cus_1", "billing_reason": reason})
+    send(client, paid)
+    assert videos_used(db_session, ws) == (0 if resets else 7)
+    # A retried delivery of the same event must not wipe videos made since.
+    set_videos_used(db_session, ws, 3)
+    send(client, paid)
+    assert videos_used(db_session, ws) == 3
+
+
+def test_subscription_sync_sets_video_limit(client, stripe_on, owner, db_session):
+    _, ws = owner
+    stripe_on.add_sub("sub_l", ws.id, plan="studio")
+    send(client, event("customer.subscription.created", stripe_on.subs["sub_l"]))
+    db_session.expire_all()
+    sub = db_session.scalar(select(Subscription).where(Subscription.workspace_id == ws.id))
+    assert (sub.video_plan, sub.video_limit) == ("studio", 20)

backend/tests/test_videos.py

@@ -0,0 +1,960 @@
+"""Videos through blog2video, with a fake blog2video: API key, denylist, the 3-step create (link, post, upload,
+multi-link), our own quotas and counters, premium gating, and workspace isolation for videos, templates, voices
+and styles (the integration guide's acceptance checklist)."""
+
+import json
+import json as jsonlib
+import logging
+import uuid
+from datetime import UTC, datetime, timedelta
+
+import httpx
+import pytest
+from sqlalchemy import select
+
+from app.config import settings
+from app.models import (
+    Artifact,
+    B2VCustomVoice,
+    B2VStyle,
+    B2VTemplate,
+    B2VVideo,
+    Document,
+    Notebook,
+    Subscription,
+    UsageCounter,
+    UserSavedVoice,
+    Workspace,
+)
+from app.services import blog2video, video_limits, video_quota
+from tests.conftest import last_code
+
+KEY = "b2v_live_test_key"
+API = "https://b2v.test"
+SARAH, BELLA = "EXAVITQu4vr4xnSDxMaL", "hpp4J3VqNfWAUOO0d1Us"  # a free and a paid built-in voice
+
+DEFAULTS: dict[str, object] = {
+    "GET /api/templates": [{"id": "default", "name": "Default"}, {"id": "geometric", "name": "Geometric",
+                                                                 "preview_colors": {"accent": "#FF0000"}}],
+    "GET /api/crafted-templates": [{"id": "crafted_neon", "name": "Neon"}],
+    "GET /api/voices/prebuilt": {"voices": [
+        {"voice_id": SARAH, "name": "Sarah - Mature", "preview_url": "https://cdn.test/sarah.mp3",
+         "labels": {"gender": "female", "accent": "american"}, "description": "Warm", "plan": "free"},
+        {"voice_id": BELLA, "name": "Bella - Bright", "preview_url": "https://cdn.test/bella.mp3",
+         "labels": {"gender": "female", "accent": "british"}, "description": "Bright", "plan": "paid"}]},
+    "GET /api/background-music/tracks": [{"track_id": "corporate_upbeat", "display_name": "Corporate Upbeat"}],
+    "GET /api/video-styles": {"styles": [
+        {"id": "explainer", "name": "Explainer", "kind": "builtin"},
+        {"id": "your_style", "name": "Your Style", "kind": "learned"},
+        {"id": "custom:7", "custom_id": 7, "name": "Mine", "kind": "custom", "guidance": "Short."},
+        {"id": "custom:9", "custom_id": 9, "name": "Theirs", "kind": "custom", "guidance": "Long."}]},
+    "POST /api/voices/custom": {"id": 31, "voice_id": "vc_designed", "name": "Narrator", "preview_url": None},
+    "POST /api/voices/clone": {"id": 32, "voice_id": "vc_clone", "name": "Me", "preview_url": None},
+    "POST /api/voices/design-from-prompt": {"previews": [{"generated_voice_id": "g1", "audio_base_64": "AAA",
+                                                          "media_type": "audio/mpeg", "duration_secs": 3}]},
+    "POST /api/video-styles/custom": {"id": "custom:41", "custom_id": 41, "name": "Punchy", "guidance": "Punchy."},
+    "POST /api/custom-templates": {"id": 58, "name": "Brand"},
+    "POST /api/custom-templates/extract-theme-from-prompt": {"extractable": True, "theme": {"colors": {}}},
+    "GET /api/auth/me": {"plan": "pro", "video_limit": 150, "videos_used_this_period": 145, "can_create_video": True,
+                         "ai_edit_allowance_remaining": 4000, "ai_edit_credits": 0, "custom_template_limit": 20,
+                         "custom_templates_created": 3},
+}
+
+
+class FakeB2V:
+    """Records every call; answers from a queue of (status, body) per "METHOD path", else a sensible default."""
+
+    def __init__(self):
+        self.calls: list[dict] = []
+        self.queued: dict[str, list[tuple[int, object]]] = {}
+        self.next_id = 812
+
+    def queue(self, method: str, path: str, *answers: tuple[int, object]):
+        self.queued.setdefault(f"{method} {path}", []).extend(answers)
+
+    def paths(self, method: str | None = None) -> list[str]:
+        return [c["path"] for c in self.calls if method is None or c["method"] == method]
+
+    def __call__(self, method, url, json=None, params=None, data=None, files=None, timeout=None, headers=None):
+        if json is not None:
+            jsonlib.dumps(json)  # what httpx does: anything that is not plain JSON fails here, as it would for real
+        path = url.removeprefix(API)
+        key = f"{method} {path}"
+        self.calls.append({"method": method, "path": path, "json": json, "data": data, "files": files,
+                           "headers": headers or {}, "params": params})
+        answers = self.queued.get(key)
+        ctype = "application/json"
+        if answers:
+            status, body = answers.pop(0)
+            if isinstance(body, Exception):
+                raise body
+        elif key in DEFAULTS:
+            status, body = 200, DEFAULTS[key]
+        elif key in ("POST /api/v1/videos", "POST /api/projects/upload"):
+            vid, self.next_id = self.next_id, self.next_id + 1
+            status, body = (202, {"video_id": vid, "state": "queued"}) if "v1" in path else (200, {"id": vid})
+        elif path.startswith("/api/embed/token/"):
+            status, body = 200, {"embed_token": "t", "preview_url": f"{API}/embed/t"}
+        elif path.endswith("/status"):
+            status, body = 200, {"status": "scripted", "step": 2, "running": True, "ready": False, "error": None,
+                                 "video_url": None}
+        elif method == "GET" and path.startswith("/api/projects/") and path.count("/") == 3:
+            status, body = 200, {"id": int(path.rsplit("/", 1)[1]), "status": "generated", "r2_video_url": None,
+                                 "scenes": [{"id": 2, "order": 2, "title": "B"}, {"id": 1, "order": 1, "title": "A"}]}
+        elif path in ("/api/voice/preview",) or path.endswith("/download"):
+            return httpx.Response(200, content=b"ID3audio", headers={"content-type": "audio/mpeg"},
+                                  request=httpx.Request(method, url))
+        else:
+            status, body = 200, {"ok": True}
+        return httpx.Response(status, content=_json(body), headers={"content-type": ctype},
+                              request=httpx.Request(method, url))
+
+
+def _json(body) -> bytes:
+    return json.dumps(body).encode()
+
+
+@pytest.fixture()
+def b2v(monkeypatch):
+    fake = FakeB2V()
+    monkeypatch.setattr(settings, "b2v_api_base_url", API)
+    monkeypatch.setattr(settings, "b2v_api_key", KEY)
+    monkeypatch.setattr(blog2video.httpx, "request", fake)
+    monkeypatch.setattr(blog2video.time, "sleep", lambda s: None)
+    blog2video.clear_cache()
+    return fake
+
+
+def register(client, email: str) -> dict:
+    client.post("/api/auth/email/register/start", json={"email": email, "password": "stardust-42", "name": "Ada"})
+    r = client.post("/api/auth/email/register/verify", json={"email": email, "code": last_code()})
+    return {"Authorization": f"Bearer {r.json()['access_token']}"}
+
+
+@pytest.fixture()
+def owner(client, db_session):
+    headers = register(client, "ada@example.com")
+    return headers, db_session.scalar(select(Workspace))
+
+
+@pytest.fixture()
+def other(client, db_session, owner):
+    headers = register(client, "grace@example.com")
+    ws = db_session.scalar(select(Workspace).where(Workspace.id != owner[1].id))
+    return headers, ws
+
+
+@pytest.fixture()
+def free_plan(monkeypatch):
+    monkeypatch.setattr(settings, "billing_enabled", True)
+
+
+def add_doc(db, ws, url: str, text: str = "") -> Document:
+    doc = Document(workspace_id=ws.id, title="On Pricing", url=url, clean_text=text, path="sources/x/pricing.md")
+    db.add(doc)
+    db.commit()
+    return doc
+
+
+def creates(fake: FakeB2V) -> list[dict]:
+    return [c for c in fake.calls if c["method"] == "POST" and c["path"] == "/api/v1/videos"]
+
+
+def used(db, ws) -> int:
+    db.expire_all()
+    return db.scalar(select(Subscription).where(Subscription.workspace_id == ws.id)).videos_used
+
+
+def make_video(client, headers, **body) -> dict:
+    r = client.post("/api/videos", json={"url": "https://ada.example.com/p/a", **body}, headers=headers)
+    assert r.status_code == 201, r.text
+    return r.json()
+
+
+def age(db, row: B2VVideo) -> None:
+    row.created_at = datetime.now(UTC) - timedelta(hours=1)
+    db.commit()
+
+
+# Client
+
+
+def test_sends_our_api_key(b2v):
+    blog2video.account()
+    assert b2v.calls[0]["headers"]["Authorization"] == f"Bearer {KEY}"
+
+
+def test_create_retries_with_the_same_idempotency_key(b2v):
+    b2v.queue("POST", "/api/v1/videos", (0, httpx.ConnectTimeout("slow")), (503, {"detail": "busy"}))
+    assert blog2video.create_video({"url": "https://a.test"}, "ws:1")["video_id"] == 812
+    assert [c["headers"]["Idempotency-Key"] for c in b2v.calls] == ["ws:1"] * 3
+
+
+def test_other_calls_are_not_retried(b2v):
+    b2v.queue("GET", "/api/auth/me", (500, {"detail": "boom"}))
+    with pytest.raises(blog2video.Upstream):
+        blog2video.account()
+    assert len(b2v.calls) == 1
+
+
+@pytest.mark.parametrize("status", [401, 402, 403])
+def test_account_problems_alert_ops(b2v, caplog, status):
+    b2v.queue("GET", "/api/auth/me", (status, {"detail": {"error": "x"}}))
+    with caplog.at_level(logging.ERROR), pytest.raises(blog2video.Upstream if status != 402
+                                                       else blog2video.AccountOutOfVideos):
+        blog2video.account()
+    assert "ALERT" in caplog.text and KEY not in caplog.text
+
+
+@pytest.mark.parametrize("method,path", [
+    ("POST", "/api/projects"), ("POST", "/api/projects/bulk"), ("GET", "/api/projects"),
+    ("GET", "/api/projects/template-availability"), ("GET", "/api/voices/saved"), ("POST", "/api/voices/saved"),
+    ("DELETE", "/api/voices/saved/abc"), ("PATCH", "/api/video-styles/builtin/explainer"),
+    ("PUT", "/api/video-styles/pin"), ("PUT", "/api/video-styles/selection"), ("PATCH", "/api/video-styles/your-style"),
+    ("DELETE", "/api/auth/me/script-preferences"),
+])
+def test_account_wide_endpoints_are_never_called(b2v, method, path):
+    with pytest.raises(blog2video.Denied):
+        blog2video.request(method, path)
+    assert b2v.calls == []
+
+
+# Create: the 3 steps
+
+
+def test_link_create_forwards_every_wizard_field(client, b2v, owner, db_session):
+    headers, ws = owner
+    body = {"stock_footage_enabled": False, "aspect_ratio": "portrait",
+            "video_length": "medium", "logo_position": "top_left", "logo_opacity": 0.5, "template": "geometric",
+            "video_style": "storytelling", "accent_color": "#FF5A1F", "bg_color": "#0B0B0F", "text_color": "#FFFFFF",
+            "content_language": "es", "voice_gender": "female", "voice_accent": "british",
+            "custom_voice_id": SARAH, "voice_emotion": '["0.5","1.0","calm","0","1"]',
+            "bgm_track_id": "corporate_upbeat", "bgm_volume": 0.2}
+    art = make_video(client, headers, **body)
+    call = creates(b2v)[0]
+    for k, v in body.items():
+        assert call["json"][k] == v, k
+    assert call["json"]["script_review_enabled"] is False
+    assert call["headers"]["Idempotency-Key"].startswith(f"{ws.id}:")
+    assert call["json"]["external_user_id"] == str(ws.id)
+    row = db_session.scalar(select(B2VVideo))
+    assert (row.b2v_video_id, row.quota_state, row.created_via, row.template_ref) == (812, "charged", "v1", "geometric")
+    assert art["content"]["b2v_video_id"] == 812 and used(db_session, ws) == 1
+
+
+def test_script_review_is_always_off(client, b2v, owner):
+    make_video(client, owner[0], script_review_enabled=True)  # an old client asking for it is ignored
+    assert creates(b2v)[0]["json"]["script_review_enabled"] is False
+
+
+def test_create_from_feed_post_and_uploaded_post(client, b2v, owner, db_session):
+    headers, ws = owner
+    doc = add_doc(db_session, ws, "https://ada.example.com/p/pricing")
+    client.post("/api/videos", json={"document_id": str(doc.id)}, headers=headers)
+    assert creates(b2v)[-1]["json"]["url"] == "https://ada.example.com/p/pricing"
+    doc = add_doc(db_session, ws, "upload://notes.md", "Charging more made my readers take the work seriously. " * 3)
+    client.post("/api/videos", json={"document_id": str(doc.id)}, headers=headers)
+    sent = creates(b2v)[-1]["json"]
+    assert "url" not in sent and sent["content"].startswith("Charging more")
+
+
+def test_notebook_posts_make_one_combined_video(client, b2v, owner, db_session):
+    headers, ws = owner
+    new = add_doc(db_session, ws, "https://ada.example.com/p/new", "Raise prices once a year, and say why. " * 3)
+    old = add_doc(db_session, ws, "https://ada.example.com/p/old", "Start cheaper than you think you should. " * 3)
+    new.title, new.published_at = "Annual raises", datetime(2026, 5, 1, tzinfo=UTC)
+    old.title, old.published_at = "Starting out", datetime(2025, 1, 1, tzinfo=UTC)
+    nb = Notebook(workspace_id=ws.id, title="Pricing series")
+    db_session.add(nb)
+    db_session.commit()
+    r = client.post("/api/videos", json={"document_ids": [str(new.id), str(old.id)], "notebook_id": str(nb.id)},
+                    headers=headers)
+    assert r.status_code == 201 and r.json()["content"]["title"] == "Pricing series"
+    sent = creates(b2v)[-1]["json"]
+    assert len(creates(b2v)) == 1 and "url" not in sent and sent["title"] == "Pricing series"
+    assert not {"document_ids", "notebook_id", "document_id"} & set(sent)  # the source is not a wizard option
+    assert sent["content"].index("# Starting out") < sent["content"].index("# Annual raises")
+    assert used(db_session, ws) == 1
+
+
+def test_one_ticked_post_goes_by_its_link(client, b2v, owner, db_session):
+    headers, ws = owner
+    doc = add_doc(db_session, ws, "https://ada.example.com/p/pricing")
+    client.post("/api/videos", json={"document_ids": [str(doc.id)]}, headers=headers)
+    assert creates(b2v)[-1]["json"]["url"] == "https://ada.example.com/p/pricing"
+
+
+def test_locked_posts_are_refused_before_charging(client, b2v, owner, db_session):
+    headers, ws = owner
+    ok = add_doc(db_session, ws, "https://ada.example.com/p/a", "Enough text to make a video from, really. " * 3)
+    locked = add_doc(db_session, ws, "https://ada.example.com/p/b")
+    locked.path, locked.metadata_json = None, {"locked": True}
+    db_session.commit()
+    for body in ({"document_id": str(locked.id)}, {"document_ids": [str(ok.id), str(locked.id)]}):
+        r = client.post("/api/videos", json=body, headers=headers)
+        assert r.status_code == 400 and "not indexed" in r.json()["detail"]
+    assert not creates(b2v) and used(db_session, ws) == 0
+
+
+def test_another_workspaces_post_is_404(client, b2v, owner, other, db_session):
+    headers, ws = owner
+    mine = add_doc(db_session, ws, "https://ada.example.com/p/a", "Enough text to make a video from, really. " * 3)
+    theirs = add_doc(db_session, other[1], "https://bo.example.com/p/b")
+    r = client.post("/api/videos", json={"document_ids": [str(mine.id), str(theirs.id)]}, headers=headers)
+    assert r.status_code == 404 and not creates(b2v)
+
+
+def test_upload_goes_to_blog2video_and_generates(client, b2v, owner, db_session):
+    headers, ws = owner
+    files = [("files", ("notes.md", b"# Notes\n" * 20, "text/markdown")), ("files", ("deck.pptx", b"x", "app/x"))]
+    r = client.post("/api/videos/upload", files=files, data={"options": json.dumps({"video_length": "medium"})},
+                    headers=headers)
+    assert r.status_code == 201, r.text
+    upload = next(c for c in b2v.calls if c["path"] == "/api/projects/upload")
+    assert [f[1][0] for f in upload["files"]] == ["notes.md", "deck.pptx"]
+    assert upload["data"]["video_length"] == "medium" and upload["data"]["script_review_enabled"] == "false"
+    assert "/api/projects/812/generate" in b2v.paths("POST")
+    row = db_session.scalar(select(B2VVideo))
+    assert row.created_via == "upload" and row.idempotency_key is None
+    client.get(f"/api/videos/{r.json()['id']}/status", headers=headers)
+    assert "/api/projects/812/status" in b2v.paths("GET")  # uploads are not under /api/v1
+
+
+def test_upload_rejects_wrong_files_before_charging(client, b2v, owner, db_session):
+    headers, ws = owner
+    r = client.post("/api/videos/upload", files=[("files", ("a.exe", b"x", "app/x"))], headers=headers)
+    assert r.status_code == 400 and used(db_session, ws) == 0 and b2v.calls == []
+
+
+def test_multi_link_makes_one_video_per_link(client, b2v, owner, db_session):
+    headers, ws = owner
+    r = client.post("/api/videos/batch", json={"urls": ["https://a.test/1", "https://a.test/2", "nope"],
+                                               "bgm_track_id": "corporate_upbeat"}, headers=headers)
+    assert r.status_code == 201 and len(r.json()) == 2
+    calls = creates(b2v)
+    assert len({c["headers"]["Idempotency-Key"] for c in calls}) == 2
+    assert all("bgm_track_id" not in c["json"] for c in calls)  # music is single-video only
+    assert used(db_session, ws) == 2
+
+
+def test_our_account_out_of_videos_refunds_the_user(client, b2v, owner, db_session, caplog):
+    headers, ws = owner
+    b2v.queue("POST", "/api/v1/videos", (402, {"detail": {"error": "quota_exceeded"}}))
+    with caplog.at_level(logging.ERROR):
+        r = client.post("/api/videos", json={"url": "https://ada.example.com/p/a"}, headers=headers)
+    assert r.status_code == 503 and "temporarily unavailable" in r.json()["detail"] and "ALERT" in caplog.text
+    assert db_session.scalar(select(Artifact).where(Artifact.type == "video")) is None
+    assert db_session.scalar(select(B2VVideo)).quota_state == "refunded" and used(db_session, ws) == 0
+
+
+def test_validation_error_refunds_and_says_what_was_wrong(client, b2v, owner, db_session):
+    headers, ws = owner
+    b2v.queue("POST", "/api/v1/videos", (422, {"detail": [{"loc": ["body", "url"], "msg": "could not fetch"}]}))
+    r = client.post("/api/videos", json={"url": "https://ada.example.com/p/a"}, headers=headers)
+    assert r.status_code == 400 and "url: could not fetch" in r.json()["detail"] and used(db_session, ws) == 0
+
+
+def test_slow_catalog_is_a_clean_error_not_a_500(client, b2v, owner, db_session):
+    headers, ws = owner
+    b2v.queue("GET", "/api/templates", (0, httpx.ReadTimeout("slow")))
+    r = client.post("/api/videos", json={"url": "https://ada.example.com/p/a", "template": "geometric"},
+                    headers=headers)
+    assert r.status_code == 502 and "not responding" in r.json()["detail"]
+    assert not creates(b2v) and used(db_session, ws) == 0
+
+
+def test_expired_catalog_is_used_when_blog2video_is_slow(client, b2v, owner):
+    make_video(client, owner[0], template="geometric")  # fills the catalog cache
+    for key, (at, value) in list(blog2video._cache.items()):
+        blog2video._cache[key] = (at - 2 * blog2video.CATALOG_TTL, value)  # an hour and more ago
+    b2v.queue("GET", "/api/templates", (0, httpx.ReadTimeout("slow")))
+    make_video(client, owner[0], template="geometric")
+    assert len(creates(b2v)) == 2
+
+
+def test_no_answer_after_retries_refunds(client, b2v, owner, db_session):
+    headers, ws = owner
+    b2v.queue("POST", "/api/v1/videos", *[(0, httpx.ConnectError("down"))] * 3)
+    r = client.post("/api/videos", json={"url": "https://ada.example.com/p/a"}, headers=headers)
+    assert r.status_code == 502 and len(creates(b2v)) == 3 and used(db_session, ws) == 0
+
+
+def test_local_limit_blocks_without_calling_out(client, b2v, owner, db_session):
+    headers, ws = owner
+    client.get("/api/videos/quota", headers=headers)  # syncs the row
+    sub = db_session.scalar(select(Subscription).where(Subscription.workspace_id == ws.id))
+    sub.videos_used = sub.video_limit
+    db_session.commit()
+    r = client.post("/api/videos", json={"url": "https://ada.example.com/p/a"}, headers=headers)
+    assert r.status_code == 402 and r.json()["detail"]["code"] == "plan_limit" and not creates(b2v)
+
+
+def test_two_workspaces_same_url_get_separate_videos(client, b2v, owner, other):
+    make_video(client, owner[0])
+    make_video(client, other[0])
+    calls = creates(b2v)
+    assert calls[0]["headers"]["Idempotency-Key"].split(":")[0] != calls[1]["headers"]["Idempotency-Key"].split(":")[0]
+
+
+def test_not_configured(client, owner):
+    r = client.post("/api/videos", json={"url": "https://ada.example.com/p/a"}, headers=owner[0])
+    assert r.status_code == 503
+
+
+# Isolation: another workspace's ids are refused before blog2video is called
+
+
+@pytest.fixture()
+def theirs(db_session, other):
+    _, ws = other
+    db_session.add_all([B2VTemplate(b2v_template_id=77, workspace_id=ws.id, name="Theirs", ready=True),
+                        B2VStyle(b2v_style_id=9, workspace_id=ws.id, name="Theirs"),
+                        B2VCustomVoice(b2v_custom_voice_id=90, workspace_id=ws.id, voice_id="vc_theirs", name="T",
+                                       source="clone")])
+    db_session.commit()
+
+
+@pytest.mark.parametrize("field,value", [("template", "custom_77"), ("video_style", "custom:9"),
+                                         ("custom_voice_id", "vc_theirs"), ("video_style", "your_style"),
+                                         ("template", "custom_12345"), ("template", "not-a-template"),
+                                         ("template", "crafted_other")])
+def test_foreign_references_are_refused_before_calling_out(client, b2v, owner, theirs, db_session, field, value):
+    headers, ws = owner
+    r = client.post("/api/videos", json={"url": "https://ada.example.com/p/a", field: value}, headers=headers)
+    assert r.status_code == 404 and not creates(b2v) and used(db_session, ws) == 0
+
+
+def test_own_references_pass(client, b2v, owner, db_session):
+    headers, ws = owner
+    db_session.add_all([B2VTemplate(b2v_template_id=58, workspace_id=ws.id, name="Mine", ready=True),
+                        B2VStyle(b2v_style_id=7, workspace_id=ws.id, name="Mine"),
+                        B2VCustomVoice(b2v_custom_voice_id=31, workspace_id=ws.id, voice_id="vc_mine", name="M",
+                                       source="prompt")])
+    db_session.commit()
+    make_video(client, headers, template="custom_58", video_style="custom:7", custom_voice_id="vc_mine")
+    make_video(client, headers, template="crafted_neon")
+
+
+def test_template_still_generating_is_refused(client, b2v, owner, db_session):
+    headers, ws = owner
+    db_session.add(B2VTemplate(b2v_template_id=58, workspace_id=ws.id, name="Mine", ready=False))
+    db_session.commit()
+    r = client.post("/api/videos", json={"url": "https://a.test/x", "template": "custom_58"}, headers=headers)
+    assert r.status_code == 400 and not creates(b2v)
+
+
+def test_other_workspace_video_is_404_everywhere(client, b2v, owner, other):
+    art = make_video(client, owner[0])
+    b2v.calls.clear()
+    for method, path in [("GET", ""), ("GET", "/status"), ("GET", "/script"), ("DELETE", ""),
+                         ("PUT", "/p/scenes/1"), ("POST", "/p/render")]:
+        r = client.request(method, f"/api/videos/{art['id']}{path}", json={}, headers=other[0])
+        assert r.status_code == 404, (method, path)
+    assert b2v.calls == []
+
+
+def test_catalog_shows_only_this_workspace(client, b2v, owner, theirs, db_session):
+    headers, ws = owner
+    db_session.add_all([B2VStyle(b2v_style_id=7, workspace_id=ws.id, name="Mine"),
+                        B2VTemplate(b2v_template_id=58, workspace_id=ws.id, name="Mine", ready=True),
+                        B2VTemplate(b2v_template_id=59, workspace_id=ws.id, name="Not yet", ready=False)])
+    db_session.commit()
+    cat = client.get("/api/videos/catalog", headers=headers).json()
+    assert [s["id"] for s in cat["video_styles"]] == ["explainer", "custom:7"]
+    assert [t["id"] for t in cat["my_templates"]] == ["custom_58"]
+
+
+# Premium (★) and per-workspace counters
+
+
+@pytest.mark.parametrize("body", [{"video_length": "detailed"}, {"video_length": "more_detailed"},
+                                  {"custom_voice_id": BELLA}, {"voice_emotion": '["0.5","1.0","calm","0","1"]'},
+                                  {"template": "crafted_neon"}])
+def test_premium_options_refused_on_free(client, b2v, owner, free_plan, db_session, body):
+    headers, ws = owner
+    r = client.post("/api/videos", json={"url": "https://a.test/x", **body}, headers=headers)
+    assert r.status_code == 402 and r.json()["detail"]["kind"] == "video_premium" and not creates(b2v)
+    assert r.json()["detail"]["upgrade_to"] == "writer"
+
+
+def test_free_plan_can_make_a_plain_video(client, b2v, owner, free_plan):
+    make_video(client, owner[0], custom_voice_id=SARAH)
+
+
+def test_ai_edits_counted_and_given_back_on_failure(client, b2v, owner, db_session):
+    headers, ws = owner
+    art = make_video(client, headers)
+    r = client.post(f"/api/videos/{art['id']}/p/scenes/1/regenerate", json={"description": "x"}, headers=headers)
+    assert r.status_code == 200 and video_limits.used(db_session, ws.id, "ai_edits") == 1
+    b2v.queue("POST", "/api/projects/812/scenes/1/regenerate", (409, {"detail": "busy"}))
+    r = client.post(f"/api/videos/{art['id']}/p/scenes/1/regenerate", json={}, headers=headers)
+    assert r.status_code == 409 and video_limits.used(db_session, ws.id, "ai_edits") == 1
+
+
+def test_ai_edits_stop_at_the_workspace_limit(client, b2v, owner, db_session):
+    headers, ws = owner
+    art = make_video(client, headers)
+    db_session.add(UsageCounter(workspace_id=ws.id, period=video_limits.period_key("ai_edits"), metric="ai_edits",
+                                used=1000))
+    db_session.commit()
+    b2v.calls.clear()
+    r = client.post(f"/api/videos/{art['id']}/p/chat", json={"message": "shorter"}, headers=headers)
+    assert r.status_code == 402 and r.json()["detail"]["kind"] == "video_limits.ai_edits" and b2v.calls == []
+
+
+def test_avatar_batch_charges_ten_per_scene(client, b2v, owner, db_session):
+    headers, ws = owner
+    art = make_video(client, headers)
+    r = client.post(f"/api/videos/{art['id']}/p/avatar-batch/authorize", json={"scene_ids": [1, 2, 3]},
+                    headers=headers)
+    assert r.status_code == 200 and video_limits.used(db_session, ws.id, "ai_edits") == 30
+
+
+def test_template_switch_uses_a_video_and_checks_the_template(client, b2v, owner, theirs, db_session):
+    headers, ws = owner
+    art = make_video(client, headers)
+    r = client.post(f"/api/videos/{art['id']}/p/change-template-regenerate-layouts", json={"template": "custom_77"},
+                    headers=headers)
+    assert r.status_code == 404 and used(db_session, ws) == 1
+    r = client.post(f"/api/videos/{art['id']}/p/change-template-regenerate-layouts", json={"template": "geometric"},
+                    headers=headers)
+    assert r.status_code == 200 and used(db_session, ws) == 2
+
+
+# Edit jobs keep blog2video's own status on the artifact (not "generating"), so the list and editor can tell them apart
+
+
+def artifact_status(db, art) -> str:
+    db.expire_all()
+    return db.get(Artifact, uuid.UUID(art["id"])).status
+
+
+@pytest.mark.parametrize("raw", ["regenerating", "voice_regenerating", "language_regenerating", "script_regenerating"])
+def test_an_edit_job_keeps_blog2videos_status(client, b2v, owner, db_session, raw):
+    headers, _ = owner
+    art = make_video(client, headers)
+    b2v.queue("GET", "/api/v1/videos/812/status", (200, {"status": raw, "ready": False}))
+    assert client.get(f"/api/videos/{art['id']}/status", headers=headers).json()["artifact_status"] == raw
+    assert artifact_status(db_session, art) == raw
+
+
+def test_starting_a_template_switch_marks_the_video(client, b2v, owner, db_session):
+    headers, _ = owner
+    art = make_video(client, headers)
+    r = client.post(f"/api/videos/{art['id']}/p/change-template-regenerate-layouts", json={"template": "geometric"},
+                    headers=headers)
+    assert r.status_code == 200 and artifact_status(db_session, art) == "regenerating"
+
+
+def test_the_list_rechecks_a_video_whose_job_ended_unwatched(client, b2v, owner, db_session):
+    headers, _ = owner
+    art = make_video(client, headers)
+    b2v.queue("GET", "/api/v1/videos/812/status", (200, {"status": "regenerating", "ready": False}),
+              (200, {"status": "generated", "ready": True}))
+    client.get(f"/api/videos/{art['id']}/status", headers=headers)
+    assert artifact_status(db_session, art) == "regenerating"
+    listed = client.get("/api/videos", headers=headers).json()
+    assert listed[0]["status"] == "ready" and listed[0]["b2v_status"] == "generated"
+
+
+def test_editor_proxy_only_allows_listed_paths(client, b2v, owner):
+    headers, _ = owner
+    art = make_video(client, headers)
+    b2v.calls.clear()
+    for method, path in [("GET", "members"), ("POST", "review"), ("POST", "launch-studio"), ("GET", "../../auth/me")]:
+        assert client.request(method, f"/api/videos/{art['id']}/p/{path}", headers=headers).status_code == 404
+    assert b2v.calls == []
+
+
+def test_editor_passes_downloads_through(client, b2v, owner):
+    headers, _ = owner
+    art = make_video(client, headers)
+    r = client.get(f"/api/videos/{art['id']}/p/download", headers=headers)
+    assert r.status_code == 200 and r.content == b"ID3audio" and r.headers["content-type"] == "audio/mpeg"
+
+
+def test_editor_premium_features_refused_on_free(client, b2v, owner, free_plan):
+    headers, _ = owner
+    art = make_video(client, headers)
+    for method, path in [("POST", "chat"), ("GET", "download-studio"), ("POST", "avatar-portrait")]:
+        r = client.request(method, f"/api/videos/{art['id']}/p/{path}", json={}, headers=headers)
+        assert r.status_code == 402, path
+
+
+# Script review
+
+
+def test_script_review_flow(client, b2v, owner, db_session):
+    headers, ws = owner
+    art = make_video(client, headers)
+    scenes = client.get(f"/api/videos/{art['id']}/script", headers=headers).json()["scenes"]
+    assert [s["id"] for s in scenes] == [1, 2]
+    draft = {"title": "A", "display_text": "Text", "narration_text": "", "draft_scenes": [], "revision": 1}
+    client.post(f"/api/videos/{art['id']}/script/scenes/1/ai-preview", json={**draft, "instruction": "punchier"},
+                headers=headers)
+    assert video_limits.used(db_session, ws.id, "ai_edits") == 1
+    r = client.post(f"/api/videos/{art['id']}/script/approve",
+                    json={"scenes": [{"id": 1, "title": "A", "narration_text": "Hi"}]}, headers=headers)
+    assert r.status_code == 200 and "/api/projects/812/script-review/approve" in b2v.paths("POST")
+
+
+# Status, refunds, sweep
+
+
+def test_failure_refunds_once_from_poller_and_sweep(client, b2v, owner, db_session, session_factory):
+    headers, ws = owner
+    art = make_video(client, headers)
+    failed = (200, {"status": "failed", "step": 1, "running": False, "error": "unreachable url"})
+    b2v.queue("GET", "/api/v1/videos/812/status", failed, failed)
+    assert client.get(f"/api/videos/{art['id']}/status", headers=headers).json()["artifact_status"] == "failed"
+    assert used(db_session, ws) == 0
+    client.get(f"/api/videos/{art['id']}/status", headers=headers)
+    age(db_session, db_session.scalar(select(B2VVideo)))
+    video_quota.sweep_failed_videos(session_factory)
+    assert used(db_session, ws) == 0
+
+
+def test_sweep_refunds_videos_nobody_polled(client, b2v, owner, db_session, session_factory):
+    headers, ws = owner
+    art = make_video(client, headers)
+    age(db_session, db_session.scalar(select(B2VVideo)))
+    b2v.queue("GET", "/api/v1/videos/812/status", (404, {"detail": "Not found"}))
+    assert video_quota.sweep_failed_videos(session_factory) == 1
+    db_session.expire_all()
+    assert used(db_session, ws) == 0 and db_session.get(Artifact, uuid.UUID(art["id"])).status == "failed"
+
+
+def test_a_finished_video_is_not_refunded_by_a_later_error(client, b2v, owner, db_session):
+    headers, ws = owner
+    art = make_video(client, headers)
+    b2v.queue("GET", "/api/v1/videos/812/status", (200, {"status": "generated", "ready": True}),
+              (200, {"status": "error", "error": "a later edit failed"}))
+    client.get(f"/api/videos/{art['id']}/status", headers=headers)
+    client.get(f"/api/videos/{art['id']}/status", headers=headers)
+    assert used(db_session, ws) == 1 and db_session.scalar(select(B2VVideo)).quota_state == "kept"
+
+
+def test_legacy_video_shows_stored_links_and_refuses_edits(client, b2v, owner, db_session):
+    headers, ws = owner
+    a = Artifact(workspace_id=ws.id, type="video", status="ready",
+                 content_json={"provider": "blog2video", "b2v_video_id": 99, "video_url": "https://cdn.test/old.mp4"})
+    db_session.add(a)
+    db_session.commit()
+    got = client.get(f"/api/videos/{a.id}", headers=headers).json()
+    assert got["legacy"] is True and got["video_url"] == "https://cdn.test/old.mp4"
+    assert client.patch(f"/api/videos/{a.id}/p/update-project", json={}, headers=headers).status_code == 410
+    assert b2v.calls == []
+
+
+def test_get_video_mints_the_preview_link_once(client, b2v, owner):
+    headers, _ = owner
+    art = make_video(client, headers)
+    first = client.get(f"/api/videos/{art['id']}", headers=headers).json()
+    client.get(f"/api/videos/{art['id']}", headers=headers)
+    assert first["preview_url"] == f"{API}/embed/t" and first["project"]["id"] == 812
+    assert len([p for p in b2v.paths("POST") if p.startswith("/api/embed/token/")]) == 1
+
+
+def test_scene_stock_clips_are_read_from_assigned_video(client, b2v, owner):
+    headers, _ = owner
+    art = make_video(client, headers)
+    clip = {"id": 7, "asset_type": "video", "filename": "scene_1_99.mp4", "r2_url": "https://r2.example/clip.mp4",
+            "excluded": False}
+    still = {"id": 8, "asset_type": "image", "filename": "img_a.webp", "r2_url": "https://r2.example/a.webp",
+             "excluded": False}
+    code = '{"layout": "news_headline", "layoutProps": {"assignedVideo": "scene_1_99.mp4"}}'
+    b2v.queue("GET", "/api/projects/812", (200, {"id": 812, "status": "generated", "assets": [clip, still],
+                                                  "scenes": [{"id": 1, "order": 1, "title": "A", "remotion_code": code}]}))
+    project = client.get(f"/api/videos/{art['id']}", headers=headers).json()["project"]
+    assert project["scenes"][0]["images"] == [{"filename": "scene_1_99.mp4", "asset_id": 7, "kind": "video",
+                                               "url": "https://r2.example/clip.mp4"}]
+    assert project["summary"]["images"] == 1 and project["summary"]["clips"] == 1
+
+
+def test_delete_removes_it_from_blog2video(client, b2v, owner):
+    headers, _ = owner
+    art = make_video(client, headers)
+    assert client.delete(f"/api/videos/{art['id']}", headers=headers).status_code == 200
+    assert "/api/projects/812" in b2v.paths("DELETE")
+
+
+def test_capacity_alert(b2v, caplog):
+    with caplog.at_level(logging.ERROR):
+        video_quota.check_capacity()
+    assert "ALERT" in caplog.text and "videos 145/150" in caplog.text
+
+
+# Voices
+
+
+def test_new_workspace_gets_starter_voices_and_library(client, b2v, owner):
+    got = client.get("/api/video-voices", headers=owner[0]).json()
+    assert [v["voice_id"] for v in got["saved"]] == [SARAH]  # free voices only
+    assert {v["voice_id"]: v["premium"] for v in got["library"]} == {SARAH: False, BELLA: True}
+
+
+def test_saving_a_paid_voice_needs_premium(client, b2v, owner, free_plan):
+    r = client.post("/api/video-voices/saved", json={"voice_id": BELLA}, headers=owner[0])
+    assert r.status_code == 402
+
+
+def test_saved_voices_never_touch_blog2video_saved_list(client, b2v, owner, db_session):
+    headers, _ = owner
+    client.post("/api/video-voices/saved", json={"voice_id": BELLA}, headers=headers)
+    client.delete(f"/api/video-voices/saved/{BELLA}", headers=headers)
+    assert not [p for p in b2v.paths() if "/voices/saved" in p]
+
+
+def test_design_keep_and_delete_a_custom_voice(client, b2v, owner, other, db_session):
+    headers, ws = owner
+    previews = client.post("/api/video-voices/design/prompt", json={"prompt": "A calm, warm narrator voice please"},
+                           headers=headers).json()["previews"]
+    kept = client.post("/api/video-voices/custom", json={"generated_voice_id": previews[0]["generated_voice_id"],
+                                                         "source": "prompt", "name": "Narrator"}, headers=headers)
+    assert kept.status_code == 201
+    assert db_session.get(UserSavedVoice, {"workspace_id": ws.id, "voice_id": "vc_designed"}).is_custom
+    assert video_limits.used(db_session, ws.id, "voice_designs_daily") == 1
+    assert video_limits.used(db_session, ws.id, "custom_voices") == 1
+    # Another workspace can not play or delete it, nor use it on a video.
+    assert client.get("/api/video-voices/custom/31/preview", headers=other[0]).status_code == 404
+    assert client.delete("/api/video-voices/custom/31", headers=other[0]).status_code == 404
+    r = client.post("/api/videos", json={"url": "https://a.test/x", "custom_voice_id": "vc_designed"},
+                    headers=other[0])
+    assert r.status_code == 404
+    assert client.delete("/api/video-voices/custom/31", headers=headers).status_code == 200
+    assert video_limits.used(db_session, ws.id, "custom_voices") == 0
+
+
+def test_clone_voice(client, b2v, owner):
+    r = client.post("/api/video-voices/clone", data={"name": "Me"}, files={"file": ("me.mp3", b"ID3", "audio/mpeg")},
+                    headers=owner[0])
+    assert r.status_code == 201 and r.json()["voice_id"] == "vc_clone"
+
+
+def test_voice_sample_returns_audio_and_counts(client, b2v, owner, db_session):
+    headers, ws = owner
+    r = client.post("/api/video-voices/sample", json={"custom_voice_id": SARAH}, headers=headers)
+    assert r.status_code == 200 and r.content == b"ID3audio"
+    assert video_limits.used(db_session, ws.id, "voice_samples_daily") == 1
+
+
+# Styles
+
+
+def test_styles_are_per_workspace(client, b2v, owner, other, db_session):
+    headers, ws = owner
+    made = client.post("/api/video-styles", json={"name": "Punchy", "guidance": "Punchy."}, headers=headers).json()
+    assert made["id"] == "custom:41" and db_session.get(B2VStyle, 41).workspace_id == ws.id
+    assert client.patch("/api/video-styles/41", json={"name": "x", "guidance": "y", "version": 0},
+                        headers=other[0]).status_code == 404
+    assert client.delete("/api/video-styles/41", headers=other[0]).status_code == 404
+
+
+# Templates
+
+
+def test_custom_templates_are_switched_off(client, b2v, owner):
+    headers, _ = owner
+    assert client.post("/api/video-templates/extract/prompt", json={"prompt": "x"}, headers=headers).status_code == 404
+    assert client.post("/api/video-templates", json={"name": "x", "theme": {}}, headers=headers).status_code == 404
+    assert client.get("/api/video-templates", headers=headers).status_code == 404
+    assert b2v.calls == []
+
+
+@pytest.mark.skip(reason="custom templates are switched off (video_templates is not mounted)")
+def test_template_create_generate_and_ready(client, b2v, owner, db_session):
+    headers, ws = owner
+    theme = client.post("/api/video-templates/extract/prompt", json={"prompt": "A bold dark brand with neon"},
+                        headers=headers).json()
+    made = client.post("/api/video-templates", json={"name": "Brand", "theme": theme["theme"]}, headers=headers)
+    assert made.status_code == 201 and made.json()["ref"] == "custom_58"
+    client.post("/api/video-templates/58/generate", headers=headers)
+    b2v.queue("GET", "/api/custom-templates/58/generation-status", (200, {"status": "complete"}))
+    assert client.get("/api/video-templates/58/generation-status", headers=headers).json()["ready"] is True
+    assert video_limits.used(db_session, ws.id, "templates") == 1
+    assert video_limits.used(db_session, ws.id, "template_ai_daily") == 2
+
+
+@pytest.mark.skip(reason="custom templates are switched off (video_templates is not mounted)")
+def test_free_plan_can_not_start_a_template(client, b2v, owner, free_plan):
+    r = client.post("/api/video-templates/extract/url", json={"url": "https://brand.test"}, headers=owner[0])
+    assert r.status_code == 402 and b2v.calls == []
+
+
+@pytest.mark.skip(reason="custom templates are switched off (video_templates is not mounted)")
+def test_template_delete_forces_only_over_own_videos(client, b2v, owner, other, db_session):
+    headers, ws = owner
+    db_session.add(B2VTemplate(b2v_template_id=58, workspace_id=ws.id, name="Mine", ready=True))
+    db_session.add(B2VVideo(workspace_id=other[1].id, b2v_video_id=5, template_ref="custom_58"))
+    db_session.commit()
+    b2v.queue("DELETE", "/api/custom-templates/58", (409, {"detail": {"error": "template_in_use"}}))
+    assert client.delete("/api/video-templates/58", headers=headers).status_code == 409
+    db_session.query(B2VVideo).delete()
+    db_session.commit()
+    b2v.queue("DELETE", "/api/custom-templates/58", (409, {"detail": {"error": "template_in_use"}}))
+    assert client.delete("/api/video-templates/58", headers=headers).status_code == 200
+    assert b2v.calls[-1]["params"] == {"force": "true"}
+
+
+@pytest.mark.skip(reason="custom templates are switched off (video_templates is not mounted)")
+def test_template_editor_is_per_workspace_and_allowlisted(client, b2v, owner, other, db_session):
+    headers, ws = owner
+    db_session.add(B2VTemplate(b2v_template_id=58, workspace_id=ws.id, name="Mine", ready=True))
+    db_session.commit()
+    assert client.get("/api/video-templates/58/p/versions", headers=headers).status_code == 200
+    assert client.get("/api/video-templates/58/p/versions", headers=other[0]).status_code == 404
+    assert client.get("/api/video-templates/58/p/internal/ids", headers=headers).status_code == 404
+    r = client.post("/api/video-templates/58/p/scenes/intro/ai-edit", json={"prompt": "bigger"}, headers=headers)
+    assert r.status_code == 200 and video_limits.used(db_session, ws.id, "ai_edits") == 1
+
+
+# Quota bookkeeping
+
+
+def test_sync_follows_effective_plan(client, owner, db_session, monkeypatch):
+    _, ws = owner
+    sub = video_quota.sync_video_quota(db_session, ws)
+    assert (sub.video_plan, sub.video_limit) == ("studio", 20)  # billing disabled
+    monkeypatch.setattr(settings, "billing_enabled", True)
+    sub.plan, sub.status = "writer", "active"
+    db_session.commit()
+    assert video_quota.sync_video_quota(db_session, ws).video_limit == 10
+    sub.status = "canceled"
+    db_session.commit()
+    sub = video_quota.sync_video_quota(db_session, ws)
+    assert (sub.video_plan, sub.video_limit) == ("free", 1)
+
+
+def test_monthly_fallback_reset(client, owner, db_session, session_factory):
+    _, ws = owner
+    sub = video_quota.sync_video_quota(db_session, ws)  # studio (billing disabled): monthly
+    now = datetime.now(UTC)
+    # No Stripe renewal, period started 40 days ago: resets.
+    sub.videos_used, sub.videos_period_start = 1, now - timedelta(days=40)
+    db_session.commit()
+    assert video_quota.reset_due_video_periods(session_factory) == 1
+    db_session.expire_all()
+    assert sub.videos_used == 0
+
+    # Monthly Stripe subscription renewing soon: left to invoice.paid.
+    sub.videos_used, sub.videos_period_start = 3, now - timedelta(days=40)
+    sub.provider_subscription_id, sub.status = "sub_1", "active"
+    sub.current_period_end = now - timedelta(days=10)
+    db_session.commit()
+    assert video_quota.reset_due_video_periods(session_factory) == 0
+
+    # Annual subscription (renews in 11 months): still resets monthly.
+    sub.current_period_end = now + timedelta(days=330)
+    db_session.commit()
+    assert video_quota.reset_due_video_periods(session_factory) == 1
+
+
+# The video's reference lives on its row
+
+
+def test_row_holds_the_full_reference(client, b2v, owner, db_session):
+    headers, ws = owner
+    art = make_video(client, headers)
+    row = db_session.scalar(select(B2VVideo))
+    assert row.user_id == ws.owner_id and row.artifact_id == uuid.UUID(art["id"])
+    assert (row.title, row.source_url, row.aspect_ratio) == ("https://ada.example.com/p/a", "https://ada.example.com/p/a",
+                                                              "landscape")
+    sent = creates(b2v)[0]["json"]["metadata"]
+    assert sent["user_id"] == str(ws.owner_id) and sent["workspace_id"] == str(ws.id)
+    assert sent["video_ref"] == str(row.id)
+    b2v.queue("GET", "/api/v1/videos/812/status", (200, {"status": "done", "ready": True,
+                                                          "video_url": "https://cdn.test/v.mp4"}))
+    client.get(f"/api/videos/{art['id']}/status", headers=headers)
+    client.get(f"/api/videos/{art['id']}", headers=headers)
+    db_session.expire_all()
+    assert row.video_url == "https://cdn.test/v.mp4" and row.preview_url == f"{API}/embed/t"
+
+
+def test_calls_use_the_row_not_the_artifact_copy(client, b2v, owner, db_session):
+    headers, _ = owner
+    art = make_video(client, headers)
+    a = db_session.get(Artifact, uuid.UUID(art["id"]))
+    a.content_json = {**a.content_json, "b2v_video_id": 999}  # a stale or tampered copy
+    db_session.commit()
+    client.patch(f"/api/videos/{art['id']}/p/update-project", json={"accent_color": "#000000"}, headers=headers)
+    assert "/api/projects/812/update-project" in b2v.paths("PATCH")
+
+
+def test_library_delete_removes_it_from_blog2video_and_keeps_the_record(client, b2v, owner, db_session):
+    headers, _ = owner
+    art = make_video(client, headers)
+    assert client.delete(f"/api/artifacts/{art['id']}", headers=headers).status_code == 200
+    assert "/api/projects/812" in b2v.paths("DELETE")
+    db_session.expire_all()
+    row = db_session.scalar(select(B2VVideo))
+    assert row.status == "deleted" and row.artifact_id is None
+
+
+# Video limits: Free 1 in total, Writer 10 a month, Studio 20 a month
+
+
+def _on_plan(db, ws, plan: str) -> None:
+    sub = db.scalar(select(Subscription).where(Subscription.workspace_id == ws.id))
+    sub.plan, sub.status = plan, "active"
+    db.commit()
+
+
+def test_plan_video_limits(client, owner, db_session, monkeypatch):
+    _, ws = owner
+    monkeypatch.setattr(settings, "billing_enabled", True)
+    video_quota.sync_video_quota(db_session, ws)
+    for plan, limit in (("free", 1), ("writer", 10), ("studio", 20)):
+        _on_plan(db_session, ws, plan)
+        assert video_quota.sync_video_quota(db_session, ws).video_limit == limit
+
+
+def test_free_is_one_video_in_total(client, b2v, owner, free_plan, db_session, session_factory):
+    headers, ws = owner
+    make_video(client, headers)
+    r = client.post("/api/videos", json={"url": "https://a.test/2"}, headers=headers)
+    assert r.status_code == 402
+    usage = client.get("/api/videos/quota", headers=headers).json()
+    assert usage["resets_at"] is None
+    sub = db_session.scalar(select(Subscription).where(Subscription.workspace_id == ws.id))
+    sub.videos_period_start = datetime.now(UTC) - timedelta(days=90)
+    db_session.commit()
+    assert video_quota.reset_due_video_periods(session_factory) == 0  # never refills
+    # Deleting the video does not give it back.
+    art_id = db_session.scalar(select(B2VVideo)).artifact_id
+    client.delete(f"/api/videos/{art_id}", headers=headers)
+    assert client.post("/api/videos", json={"url": "https://a.test/3"}, headers=headers).status_code == 402
+
+
+def test_free_video_that_failed_is_given_back(client, b2v, owner, free_plan, db_session):
+    headers, ws = owner
+    b2v.queue("POST", "/api/v1/videos", (422, {"detail": "bad url"}))
+    assert client.post("/api/videos", json={"url": "https://a.test/1"}, headers=headers).status_code == 400
+    make_video(client, headers)
+
+
+def test_dropping_to_free_counts_what_was_made(client, b2v, owner, db_session, monkeypatch):
+    headers, ws = owner
+    monkeypatch.setattr(settings, "billing_enabled", True)
+    video_quota.sync_video_quota(db_session, ws)
+    _on_plan(db_session, ws, "writer")
+    for i in range(3):
+        make_video(client, headers, url=f"https://a.test/{i}")
+    _on_plan(db_session, ws, "free")
+    usage = client.get("/api/videos/quota", headers=headers).json()
+    assert (usage["used"], usage["limit"]) == (3, 1)
+    assert client.post("/api/videos", json={"url": "https://a.test/x"}, headers=headers).status_code == 402
+
+
+def test_list_restores_a_video_whose_library_item_went_missing(client, b2v, owner, db_session):
+    headers, _ = owner
+    art = make_video(client, headers)
+    row = db_session.scalar(select(B2VVideo))
+    row.artifact_id, row.status = None, "generated"
+    db_session.delete(db_session.get(Artifact, uuid.UUID(art["id"])))
+    db_session.commit()
+    listed = client.get("/api/videos", headers=headers).json()
+    assert len(listed) == 1 and listed[0]["status"] == "ready"
+    b2v.calls.clear()
+    client.get(f"/api/videos/{listed[0]['id']}/status", headers=headers)
+    assert "/api/v1/videos/812/status" in b2v.paths("GET")  # the same blog2video video
+    assert len(client.get("/api/videos", headers=headers).json()) == 1  # restored once

docs/BLOG2VIDEO.md

@@ -0,0 +1,131 @@
+# blog2video integration
+
+Videos are made and edited by blog2video. Notestack is an ordinary blog2video API customer: we own one paid
+blog2video account (Pro, topped up with per-video credits) and the backend calls its public `/api/v1` API with that
+account's key. Every video is charged to our account; we charge our workspaces from our own allowance.
+
+```
+Browser ──► /api/videos/* (backend/app/routers/videos.py) ──(Bearer b2v_live_…)──► blog2video /api/v1
+                 ├─ checks the session and workspace
+                 ├─ reserves / refunds the workspace's allowance (subscriptions)
+                 └─ records which video belongs to which workspace (b2v_videos)
+```
+
+The browser never talks to blog2video, and the key never reaches the browser or the logs.
+
+## Settings
+
+Backend `.env` only (never a `VITE_` variable):
+
+| Env var | Value |
+|---|---|
+| `B2V_API_BASE_URL` | blog2video API host, no trailing slash (`B2V_API_URL` is still read as a fallback) |
+| `B2V_API_KEY` | `b2v_live_…`, from blog2video → Account → API keys on our Pro account |
+| `B2V_TIMEOUT_SECONDS` | create timeout (default 30); every other call uses 10s |
+| `B2V_CAPACITY_ALERT_BELOW` | log an `ALERT` when our account has fewer videos left (default 20) |
+
+A revoked or rotated key answers 401; a blog2video account that dropped to Free answers 403 to everything. Both
+log an `ALERT` line and users see "temporarily unavailable".
+
+## Ownership
+
+Everything made with the key (videos, custom templates, custom voices, styles) belongs to one blog2video account,
+and blog2video's ownership checks stop at the account. Notestack is the only place each workspace's things are kept
+apart (`backend/app/services/b2v_access.py`):
+
+| Table | What | Used as |
+|---|---|---|
+| `b2v_videos` | videos (also the allowance ledger) | project id; `created_via` v1 or upload |
+| `b2v_templates` | custom templates (`ready` once generated) | `template: "custom_<id>"` |
+| `b2v_custom_voices` | designed and cloned voices | `custom_voice_id: "<voice_id>"` |
+| `user_saved_voices` | "My voices" (kept only here) | the wizard's voice list |
+| `b2v_styles` | custom video styles | `video_style: "custom:<id>"` |
+| `usage_counters` | per-workspace counters (below) | |
+
+Every route that takes one of these ids checks it is the workspace's (404 otherwise), and every create or edit body
+has its `template`, `video_style` and `custom_voice_id` checked before it is forwarded. Lists come from these tables.
+Account-wide endpoints (`POST /api/projects`, `/api/projects/bulk`, `GET /api/projects`, `/api/voices/saved*`,
+built-in style overrides, style pin/selection, "Your Style", script preferences) are refused in
+`blog2video.DENIED` before anything is sent.
+
+## Routes
+
+| Notestack | blog2video |
+|---|---|
+| `POST /api/videos` (link, text, a post) | `POST /api/v1/videos` with `Idempotency-Key: <workspace>:<uuid>` |
+| `POST /api/videos/upload` (≤5 files) | `POST /api/projects/upload` then `/generate` |
+| `POST /api/videos/batch` (≤10 links) | one `POST /api/v1/videos` per link |
+| `GET /api/videos/{id}/status` | `/api/v1/videos/{id}/status`, or `/api/projects/{id}/status` for uploads |
+| `/api/videos/{id}/script*` | `/api/projects/{id}/script-review/*` |
+| `/api/videos/{id}/p/<path>` | `/api/projects/{id}/<path>`, allowlisted in `routers/video_edit.py` |
+| `/api/video-voices/*` | `/api/voices/design-from-*`, `/api/voices/custom*`, `/api/voices/clone`, `/api/voice/preview` |
+| `/api/video-templates/*` | `/api/custom-templates/*` (editor paths allowlisted) |
+| `/api/video-styles/*` | `/api/video-styles/ai-draft`, `/api/video-styles/custom*` |
+
+The live preview link comes from `POST /api/embed/token/{id}` and is safe for the browser.
+
+## Premium and per-workspace limits
+
+blog2video checks every limit against our Pro account, so every workspace passes its checks. Notestack divides them:
+each plan row has `video_premium` (★: detailed lengths, paid and custom voices, advanced voice tuning, voice samples,
+AI script rewrites, AI chat, avatars, designer templates, the source download) and `video_limits`:
+
+| Metric | Period | Free / Writer / Studio | Counts |
+|---|---|---|---|
+| `ai_edits` | month | 20 / 300 / 1000 | scene regenerate/add, AI image, stock clip, AI chat, AI rewrites, template AI edits, avatars (10 per scene) |
+| `templates` | lifetime | 0 / 2 / 5 | custom templates made (blog2video slots are never given back) |
+| `template_ai_daily` | day | 0 / 3 / 5 | theme from a document or prompt, code generation |
+| `voice_designs_daily` | day | 0 / 5 / 10 | voice designs |
+| `voice_samples_daily` | day | 0 / 20 / 40 | voice samples |
+| `custom_voices` | total | 0 / 3 / 10 | kept or cloned voices (a delete frees one) |
+
+Edit a plan row to change them. A counter is given back when blog2video refuses the call. A template switch also
+uses a video.
+
+## Quota
+
+One row per workspace in `subscriptions`, enforced only by us (`backend/app/services/video_quota.py`):
+
+| Column | Meaning |
+|---|---|
+| `video_plan` | effective plan id (`free`, `writer`, `studio`) |
+| `video_limit` | videos per period, from the plan |
+| `videos_used` | videos made this period |
+| `videos_period_start` | start of the current period |
+
+- **Reserve** before calling blog2video: `videos_used + 1` only while below `video_limit`, in one `UPDATE`. At the
+  limit we answer 402 `plan_limit` and blog2video is never called.
+- **Refund exactly once** (conditional `UPDATE b2v_videos SET quota_state = 'refunded' WHERE quota_state = 'charged'`)
+  when the create is refused (402, 422, key/plan problems), gets no answer after 3 tries with the same
+  `Idempotency-Key`, or generation fails (status `failed`/`error`, or 404).
+- The worker's `video_refund_sweep` (every 10 min) checks charged, unfinished videos older than 30 minutes, for users
+  who closed the tab. `video_capacity_check` (hourly) reads `GET /api/v1/me` and alerts when we run low.
+- Resets: Stripe `invoice.paid` with `billing_reason` `subscription_cycle` or `subscription_create`; otherwise the
+  hourly `video_period_reset` resets any period older than a month (free, billing disabled, annual plans).
+
+A 402 `quota_exceeded` from blog2video means **our** account is out of videos, not the user: they are refunded and
+see "temporarily unavailable"; buy credits. Our users' limits added up can exceed the account, so watch the alert.
+
+## Videos made before the switch
+
+Videos made through the old partner integration belonged to a blog2video service account that is now deactivated;
+the key gets 404 for them. They have no `b2v_videos` row, so the API treats them as legacy: `GET` returns the stored
+`video_url`/`preview_url` with `legacy: true`, and edits answer 410. blog2video can move them to our account on
+request if we ever need them editable.
+
+## Clean-up after the switch
+
+The partner-token code and settings (`B2V_PARTNER_SLUG`, `B2V_PARTNER_SECRET`) are gone. blog2video used to connect
+to our database, so drop that access:
+
+```sql
+REVOKE ALL ON public.subscriptions FROM b2v_partner;
+DROP VIEW IF EXISTS b2v_quota;
+DROP ROLE IF EXISTS b2v_partner;
+```
+
+and remove blog2video's server IP from the database firewall.
+
+## Local development
+
+Set `B2V_API_BASE_URL` and a test key. Unit tests (`backend/tests/test_videos.py`) use a fake blog2video.

frontend/seo/prerender.ts

@@ -240,6 +240,16 @@ function head(r: Rendered, origin: string) {
   return tags.join("\n    ");
 }
 
+/**
+ * The static copy is for crawlers and screen readers, not for people: until the app's JS and CSS load it would flash
+ * as an unstyled page of links. Keep it in the document but visually hidden (not display:none, which some crawlers
+ * skip), and paint the app's black background from the first frame. React's createRoot replaces it on load.
+ */
+const STATIC_STYLE =
+  "<style>html,body{background:#000;color:#fff;margin:0}" +
+  ".seo-static{position:absolute;width:1px;height:1px;margin:-1px;padding:0;overflow:hidden;" +
+  "clip:rect(0 0 0 0);clip-path:inset(50%);white-space:nowrap;border:0}</style>";
+
 export function prerenderPlugin(siteUrl: string): Plugin {
   const origin = siteUrl.replace(/\/+$/, "");
   let config: ResolvedConfig;
@@ -255,14 +265,14 @@ export function prerenderPlugin(siteUrl: string): Plugin {
       const all = routes();
       for (const r of all) {
         const html = template
-          .replace("</head>", `    ${head(r, origin)}\n  </head>`)
-          .replace('<div id="root"></div>', `<div id="root">${r.body}</div>`);
+          .replace("</head>", `    ${head(r, origin)}\n    ${STATIC_STYLE}\n  </head>`)
+          .replace('<div id="root"></div>', `<div id="root"><div class="seo-static">${r.body}</div></div>`);
         const file = r.path === "/" ? path.join(outDir, "index.html") : path.join(outDir, `${r.path.slice(1)}.html`);
         await mkdir(path.dirname(file), { recursive: true });
         await writeFile(file, html, "utf8");
       }
       // Signed in and unknown routes fall back to an app shell with no page content (see public/_redirects).
-      await writeFile(path.join(outDir, "app.html"), template.replace("</head>", `    <meta name="robots" content="noindex" />\n    <title>Notestack</title>\n  </head>`), "utf8");
+      await writeFile(path.join(outDir, "app.html"), template.replace("</head>", `    <meta name="robots" content="noindex" />\n    <title>Notestack</title>\n    ${STATIC_STYLE}\n  </head>`), "utf8");
       config.logger.info(`prerendered ${all.length} public routes`);
     },
   };

frontend/src/App.tsx

@@ -18,6 +18,10 @@ import Resurface from "./pages/Resurface";
 import Settings from "./pages/Settings";
 import Sources from "./pages/Sources";
 import Studio from "./pages/Studio";
+import VideoCreate from "./pages/VideoCreate";
+import VideoEditor from "./pages/VideoEditor";
+import VideoVoices from "./pages/VideoVoices";
+import Videos from "./pages/Videos";
 import TopicMap from "./pages/TopicMap";
 import { ToolPage, ToolsHub } from "./pages/Tools";
 import VoiceProfile from "./pages/VoiceProfile";
@@ -55,6 +59,10 @@ export default function App() {
         <Route index element={<MissionControl />} />
         <Route path="notebooks" element={<Notebooks />} />
         <Route path="notebooks/:id" element={<NotebookView />} />
+        <Route path="videos" element={<Videos />} />
+        <Route path="videos/new" element={<VideoCreate />} />
+        <Route path="videos/voices" element={<VideoVoices />} />
+        <Route path="videos/:id" element={<VideoEditor />} />
         <Route path="sources" element={<Sources />} />
         <Route path="map" element={<TopicMap />} />
         <Route path="voice" element={<VoiceProfile />} />

frontend/src/api/client.ts

@@ -87,16 +87,31 @@ async function tryRefresh(): Promise<boolean> {
   return true;
 }
 
-export async function api<T>(path: string, init: RequestInit = {}, retry = true): Promise<T> {
+async function request(path: string, init: RequestInit, retry: boolean): Promise<Response> {
   const headers = new Headers(init.headers);
-  if (init.body && !headers.has("Content-Type")) headers.set("Content-Type", "application/json");
+  // FormData sets its own multipart Content-Type (with the boundary); everything else is JSON.
+  if (init.body && !(init.body instanceof FormData) && !headers.has("Content-Type")) {
+    headers.set("Content-Type", "application/json");
+  }
   if (tokens.access) headers.set("Authorization", `Bearer ${tokens.access}`);
   const res = await fetch(`${BASE}${path}`, { ...init, headers });
-  if (res.status === 401 && retry && (await tryRefresh())) return api<T>(path, init, false);
+  if (res.status === 401 && retry && (await tryRefresh())) return request(path, init, false);
   if (!res.ok) throw await parseError(res);
-  return (await res.json()) as T;
+  return res;
+}
+
+export async function api<T>(path: string, init: RequestInit = {}, retry = true): Promise<T> {
+  return (await (await request(path, init, retry)).json()) as T;
+}
+
+/** A binary answer (audio, a download) as a Blob. */
+export async function apiBlob(path: string, init: RequestInit = {}): Promise<Blob> {
+  return (await request(path, init, true)).blob();
 }
 
+/** Multipart upload to our API (files plus form fields). */
+export const postForm = <T>(path: string, form: FormData) => api<T>(path, { method: "POST", body: form });
+
 export const post = <T>(path: string, body?: unknown) =>
   api<T>(path, { method: "POST", body: body === undefined ? undefined : JSON.stringify(body) });
 

frontend/src/api/endpoints.ts

@@ -1,4 +1,4 @@
-import { api, del, patch, post, put, qs, uploadFile } from "./client";
+import { api, apiBlob, del, patch, post, postForm, put, qs, uploadFile } from "./client";
 import type {
   Artifact,
   ArtifactType,
@@ -28,6 +28,29 @@ import type {
   VoiceDesignPreview,
   VoiceProfileData,
   VoiceState,
+  ExtractedTheme,
+  LegacyVideo,
+  MyTemplate,
+  ScriptPreview,
+  ScriptScene,
+  TemplateGeneration,
+  TemplatesResponse,
+  VideoCatalog,
+  VideoConfig,
+  VideoCreateBody,
+  VideoCustomVoice,
+  VideoDesignedVoice,
+  VideoJobState,
+  VideoListItem,
+  VideoOptions,
+  VideoProject,
+  VideoProjectData,
+  VideoQuota,
+  VideoSavedVoice,
+  VideoScene,
+  VideoStatus,
+  VideoStyleItem,
+  VideoVoicesResponse,
 } from "./types";
 
 type SourceJob = { source: Source; job: Job };
@@ -78,7 +101,7 @@ export type GenerateBody = {
   archive?: boolean;
   format?: "deep_dive" | "brief" | "debate";
   minutes?: number;
-  style?: "short" | "explainer" | "audiogram";
+  style?: "audiogram";
   audio_artifact_id?: string;
   slides?: { heading: string; body: string }[];
   parent_id?: string;
@@ -198,3 +221,215 @@ export const billingApi = {
   portal: () => post<{ url: string }>("/api/billing/portal"),
   confirm: (sessionId: string) => post<BillingStatus>("/api/billing/confirm", { session_id: sessionId }),
 };
+
+function form(fields: Record<string, string | number | boolean | Blob | null | undefined>): FormData {
+  const f = new FormData();
+  for (const [k, v] of Object.entries(fields)) {
+    if (v === undefined || v === null) continue;
+    f.append(k, v instanceof Blob ? v : String(v));
+  }
+  return f;
+}
+
+export type ScriptDraft = { title: string; display_text: string; narration_text: string; revision: number;
+                            draft_scenes: { id: number; title: string; display_text: string | null; narration_text: string }[] };
+
+/** Videos are made by blog2video; the backend proxies every call. Ids here are our artifact ids. */
+export const videosApi = {
+  config: () => api<VideoConfig>("/api/videos/config"),
+  quota: () => api<VideoQuota>("/api/videos/quota"),
+  catalog: () => api<VideoCatalog>("/api/videos/catalog"),
+  list: () => api<VideoListItem[]>("/api/videos"),
+  create: (body: VideoCreateBody) => post<Artifact>("/api/videos", body),
+  /** Multi-link: one video per link. Items with `error` say where it stopped (usually the allowance ran out). */
+  createBatch: (urls: string[], options: VideoOptions) =>
+    post<(Artifact | { error: string; url: string })[]>("/api/videos/batch", { ...options, urls }),
+  /** Up to 5 documents; blog2video reads them itself. */
+  createFromFiles: (files: File[], options: VideoOptions) => {
+    const f = new FormData();
+    files.forEach((file) => f.append("files", file));
+    f.append("options", JSON.stringify(options));
+    return postForm<Artifact>("/api/videos/upload", f);
+  },
+  get: (id: string) => api<VideoProject | LegacyVideo>(`/api/videos/${id}`),
+  status: (id: string) => api<VideoStatus>(`/api/videos/${id}/status`),
+  remove: (id: string) => del(`/api/videos/${id}`),
+  // Script review
+  script: (id: string) => api<{ status: string; scenes: ScriptScene[] }>(`/api/videos/${id}/script`),
+  narrationPreview: (id: string, sceneId: number, body: ScriptDraft) =>
+    post<ScriptPreview>(`/api/videos/${id}/script/scenes/${sceneId}/narration-preview`, body),
+  aiPreview: (id: string, sceneId: number, body: ScriptDraft & { instruction: string }) =>
+    post<ScriptPreview>(`/api/videos/${id}/script/scenes/${sceneId}/ai-preview`, body),
+  approveScript: (id: string, scenes: (ScriptScene & { source_fingerprint?: string; accepted_ai_instructions?: string[] })[]) =>
+    post<unknown>(`/api/videos/${id}/script/approve`, { scenes }),
+};
+
+const P = (id: string, path: string) => `/api/videos/${id}/p/${path}`;
+export type LayoutSchema = Record<string, { defaults?: Record<string, unknown>; fields?: Record<string, unknown>[] }>;
+
+/** The template's layouts, from blog2video's GET .../layouts. Variants ("news_headline__v2") are visual styles of a base
+ * layout: layout_variants maps a base to its variant ids, layout_variant_labels names each ("Broadsheet"). */
+export type LayoutInfo = {
+  layouts: string[];
+  layout_names?: Record<string, string>;
+  layout_prop_schema?: LayoutSchema;
+  layout_variants?: Record<string, string[]>;
+  layout_variant_labels?: Record<string, string>;
+};
+
+export type StockClip = { provider: string; id: string; preview_url: string; thumbnail_url: string; download_url: string;
+                          width: number; height: number; duration: number; author: string; page_url: string };
+
+/** The editor: blog2video's project endpoints, through our allowlisted proxy. */
+export const videoEditApi = {
+  project: (id: string) => api<VideoProjectData>(P(id, "")),
+  updateProject: (id: string, body: Partial<VideoProjectData>) => patch<VideoProjectData>(P(id, "update-project"), body),
+  // Scenes
+  updateScene: (id: string, sceneId: number, body: Partial<Pick<VideoScene, "title" | "display_text" | "narration_text" |
+    "visual_description" | "duration_seconds" | "extra_hold_seconds" | "remotion_code">>) =>
+    put<VideoScene>(P(id, `scenes/${sceneId}`), body),
+  deleteScene: (id: string, sceneId: number) => del<unknown>(P(id, `scenes/${sceneId}`)),
+  reorderScenes: (id: string, scene_orders: { scene_id: number; order: number }[]) =>
+    post<VideoScene[]>(P(id, "scenes/reorder"), { scene_orders }),
+  regenerateScene: (id: string, sceneId: number, body: { description?: string; narration_text?: string;
+    regenerate_voiceover?: boolean; voiceover_verbatim?: boolean; layout?: string; image?: File }) =>
+    postForm<VideoScene>(P(id, `scenes/${sceneId}/regenerate`), form(body)),
+  addScene: (id: string, prompt: string, position?: number) => post<VideoJobState>(P(id, "scenes/add"), { prompt, position }),
+  addSceneStatus: (id: string) => api<VideoJobState | null>(P(id, "scenes/add-status")),
+  // Images
+  uploadImage: (id: string, sceneId: number, image: File) => postForm<VideoScene>(P(id, `scenes/${sceneId}/image`), form({ image })),
+  generateImage: (id: string, sceneId: number, image_description: string) =>
+    // Not saved on the scene: the image comes back for the user to keep (uploadImage) or discard.
+    post<{ image_base64: string; refined_prompt: string }>(P(id, `scenes/${sceneId}/generate-image`), { image_description }),
+  imageFocus: (id: string, sceneId: number, body: { image_focus_x: number; image_focus_y: number; image_zoom?: number }) =>
+    patch<VideoScene>(P(id, `scenes/${sceneId}/image-focus`), body),
+  moveImage: (id: string, from_scene_id: number, to_scene_id: number) =>
+    post<unknown>(P(id, "images/move"), { from_scene_id, to_scene_id }),
+  swapImages: (id: string, first_scene_id: number, second_scene_id: number) =>
+    post<unknown>(P(id, "images/swap"), { first_scene_id, second_scene_id }),
+  duplicateImage: (id: string, source_scene_id: number, target_scene_id: number) =>
+    post<unknown>(P(id, "images/duplicate"), { source_scene_id, target_scene_id }),
+  /** Deletes the image or clip from the video for good (files too) and takes it off any scene. */
+  /** The template's layouts; layout_prop_schema[layout].defaults holds its default font sizes (meta.json). */
+  layouts: (id: string) => api<LayoutInfo>(P(id, "layouts")),
+  deleteAsset: (id: string, assetId: number) => del<unknown>(P(id, `assets/${assetId}`)),
+  assignImage: (id: string, scene_id: number, asset_id: number) =>
+    post<unknown>(P(id, "images/assign-existing"), { scene_id, asset_id }),
+  // Stock footage
+  searchStock: (id: string, q: string) => api<{ clips: StockClip[] }>(P(id, `stock-footage/search${qs({ q })}`)),
+  /** Downloads the clip into the project (a new asset). It is not on the scene until linkStock. */
+  useStock: (id: string, sceneId: number, c: StockClip) =>
+    post<{ asset_id: number; filename: string }>(P(id, `scenes/${sceneId}/stock-footage`), { provider: c.provider, clip_id: c.id,
+      download_url: c.download_url, width: c.width, height: c.height, duration: c.duration, author: c.author,
+      page_url: c.page_url }),
+  /** Put a clip that is already in the project on a scene (assignedVideo). */
+  linkStock: (id: string, scene_id: number, filename: string) =>
+    post<unknown>(P(id, "stock-footage/link"), { scene_id, filename }),
+  pendingStock: (id: string) => api<{ scenes?: unknown[]; [k: string]: unknown }>(P(id, "stock-footage/pending")),
+  approveStock: (id: string) => post<unknown>(P(id, "stock-footage/approve")),
+  rejectStock: (id: string) => post<unknown>(P(id, "stock-footage/reject")),
+  // Voice, voiceovers, language, template
+  uploadVoiceover: (id: string, sceneId: number, audio: File) =>
+    postForm<VideoScene>(P(id, `scenes/${sceneId}/voiceover`), form({ audio })),
+  deleteVoiceover: (id: string) => post<unknown>(P(id, "delete-voiceover")),
+  changeVoice: (id: string, body: { voice_gender?: string; voice_accent?: string; custom_voice_id?: string | null;
+    voice_emotion?: string | null }) => post<VideoJobState>(P(id, "change-voice"), body),
+  voiceStatus: (id: string) => api<VideoJobState>(P(id, "voice-change-status")),
+  changeLanguage: (id: string, content_language: string) => post<VideoJobState>(P(id, "change-language"), { content_language }),
+  languageStatus: (id: string) => api<VideoJobState>(P(id, "language-change-status")),
+  changeTemplate: (id: string, template: string) =>
+    post<VideoJobState>(P(id, "change-template-regenerate-layouts"), { template }),
+  templateStatus: (id: string) => api<VideoJobState>(P(id, "template-change-status")),
+  // Refresh the script (keeps narration and voiceovers, rewrites titles and layouts)
+  refreshScript: (id: string, user_instruction?: string) => post<VideoJobState>(P(id, "regenerate-script"), { user_instruction }),
+  refreshStatus: (id: string) => api<VideoJobState>(P(id, "regenerate-script-status")),
+  refreshPreview: (id: string) => api<Record<string, unknown>>(P(id, "regenerate-script/preview")),
+  refreshVerify: (id: string) => post<unknown>(P(id, "regenerate-script/verify")),
+  refreshRetry: (id: string, user_instruction?: string) =>
+    post<VideoJobState>(P(id, "regenerate-script/regenerate"), { user_instruction }),
+  // AI chat editing ★
+  chat: (id: string, message: string, conversation_id?: number) =>
+    post<{ reply?: string; message?: string; conversation_id?: number; [k: string]: unknown }>(P(id, "chat"), { message, conversation_id }),
+  chatHistory: (id: string) => api<unknown>(P(id, "chat/history")),
+  // Avatars ★
+  authorizeAvatars: (id: string, scene_ids: number[], avatar_preset?: string, avatar_motion_style?: string) =>
+    post<unknown>(P(id, "avatar-batch/authorize"), { scene_ids, avatar_preset, avatar_motion_style }),
+  makeAvatar: (id: string, sceneId: number, avatar_preset?: string) =>
+    postForm<unknown>(P(id, `scenes/${sceneId}/avatar`), form({ avatar_preset })),
+  avatarProgress: (id: string) => api<Record<string, unknown>>(P(id, "avatar-progress")),
+  deleteAvatar: (id: string, sceneId: number) => del<unknown>(P(id, `scenes/${sceneId}/avatar`)),
+  uploadPortrait: (id: string, file: File) => postForm<unknown>(P(id, "avatar-portrait"), form({ file })),
+  deletePortrait: (id: string) => del<unknown>(P(id, "avatar-portrait")),
+  avatarAppearance: (id: string, sceneId: number, body: { avatar_shape?: string; avatar_size?: number;
+    avatar_position?: string; avatar_opacity?: number }) => patch<unknown>(P(id, `scenes/${sceneId}/avatar-appearance`), body),
+  // Render, download, frames
+  /** force renders again even when an MP4 is already on R2 (blog2video otherwise just returns the old one). */
+  render: (id: string, { force = false, resolution = "1080p" }: { force?: boolean; resolution?: string } = {}) =>
+    post<VideoJobState>(P(id, `render${qs({ resolution, force_render: force || undefined })}`)),
+  renderStatus: (id: string) => api<VideoJobState>(P(id, "render-status")),
+  cancelRender: (id: string) => post<unknown>(P(id, "cancel-render")),
+  downloadUrl: (id: string) => api<{ url: string }>(P(id, "download-url")),
+  downloadStudio: (id: string) => apiBlob(P(id, "download-studio")),
+  still: (id: string, frame: number) => apiBlob(P(id, `render-still${qs({ frame })}`)),
+};
+
+export const videoVoicesApi = {
+  list: () => api<VideoVoicesResponse>("/api/video-voices"),
+  save: (voice_id: string) => post<VideoSavedVoice>("/api/video-voices/saved", { voice_id }),
+  unsave: (voice_id: string) => del(`/api/video-voices/saved/${encodeURIComponent(voice_id)}`),
+  designFromPrompt: (prompt: string) => post<{ previews: VideoDesignedVoice[] }>("/api/video-voices/design/prompt", { prompt }),
+  designFromPreset: (body: { gender: string; age: string; persona: string; speed: string; accent: string }) =>
+    post<{ previews: VideoDesignedVoice[] }>("/api/video-voices/design/preset", body),
+  keep: (body: { generated_voice_id: string; source: "prompt" | "preset"; name: string; prompt_text?: string }) =>
+    post<VideoCustomVoice>("/api/video-voices/custom", body),
+  clone: (name: string, file: File, remove_background_noise = true) =>
+    postForm<VideoCustomVoice>("/api/video-voices/clone", form({ name, file, remove_background_noise })),
+  customPreview: (customId: number) =>
+    api<{ preview_url: string | null; ready: boolean }>(`/api/video-voices/custom/${customId}/preview`),
+  removeCustom: (customId: number) => del(`/api/video-voices/custom/${customId}`),
+  /** ★ A few seconds of the voice with the chosen tuning (audio/mpeg). */
+  sample: (body: { voice_gender: string; voice_accent: string; custom_voice_id?: string; voice_emotion?: string;
+                   video_style?: string }) => apiBlob("/api/video-voices/sample", { method: "POST", body: JSON.stringify(body) }),
+};
+
+export const videoStylesApi = {
+  list: () => api<VideoStyleItem[]>("/api/video-styles"),
+  aiDraft: (prompt: string) => post<{ name: string; guidance: string }>("/api/video-styles/ai-draft", { prompt }),
+  create: (body: { name: string; guidance: string; creation_method: "manual" | "ai"; source_prompt?: string }) =>
+    post<VideoStyleItem>("/api/video-styles", body),
+  update: (styleId: number, body: { name: string; guidance: string; version: number }) =>
+    patch<VideoStyleItem>(`/api/video-styles/${styleId}`, body),
+  remove: (styleId: number) => del(`/api/video-styles/${styleId}`),
+};
+
+const T = (id: number, path: string) => `/api/video-templates/${id}/p/${path}`;
+
+export const videoTemplatesApi = {
+  list: () => api<TemplatesResponse>("/api/video-templates"),
+  extractFromUrl: (url: string) => post<ExtractedTheme>("/api/video-templates/extract/url", { url }),
+  extractFromPrompt: (prompt: string, name?: string) =>
+    post<ExtractedTheme>("/api/video-templates/extract/prompt", { prompt, name }),
+  extractFromDoc: (file: File, name: string) => postForm<ExtractedTheme>("/api/video-templates/extract/doc", form({ file, name })),
+  create: (body: { name: string; theme: Record<string, unknown>; source_url?: string; logo_urls?: string[];
+                   og_image?: string; screenshot_url?: string }) => post<MyTemplate>("/api/video-templates", body),
+  generate: (id: number) => post<unknown>(`/api/video-templates/${id}/generate`),
+  generationStatus: (id: number) => api<TemplateGeneration>(`/api/video-templates/${id}/generation-status`),
+  remove: (id: number) => del(`/api/video-templates/${id}`),
+  // Editing
+  get: (id: number) => api<Record<string, unknown>>(T(id, "")),
+  update: (id: number, body: { name?: string; theme?: Record<string, unknown> }) => put<Record<string, unknown>>(T(id, ""), body),
+  uploadLogo: (id: number, file: File) => postForm<unknown>(T(id, "upload-logo"), form({ file })),
+  aiEdit: (id: number, sceneKey: string, prompt: string) => post<unknown>(T(id, `scenes/${sceneKey}/ai-edit`), { prompt }),
+  aiEditStatus: (id: number, sceneKey: string) => api<VideoJobState>(T(id, `scenes/${sceneKey}/ai-edit/status`)),
+  drafts: (id: number) => api<unknown>(T(id, "scene-drafts")),
+  applyDraft: (id: number, sceneKey: string) => post<unknown>(T(id, `scenes/${sceneKey}/draft/apply`)),
+  discardDraft: (id: number, sceneKey: string) => post<unknown>(T(id, `scenes/${sceneKey}/draft/discard`)),
+  fontDefaults: (id: number, body: Record<string, unknown>, sceneKey?: string) =>
+    patch<unknown>(T(id, sceneKey ? `scenes/${sceneKey}/font-defaults` : "scenes/font-defaults"), body),
+  chart: (id: number, sceneKey: string, body: Record<string, unknown>) => patch<unknown>(T(id, `scenes/${sceneKey}/chart`), body),
+  versions: (id: number) => api<unknown>(T(id, "versions")),
+  rollback: (id: number, versionId: number) => post<unknown>(T(id, `versions/${versionId}/rollback`)),
+  regenerate: (id: number) => post<unknown>(T(id, "regenerate-code")),
+  resume: (id: number) => post<unknown>(T(id, "resume-generation")),
+  rate: (id: number, body: Record<string, unknown>) => post<unknown>(T(id, "rating"), body),
+};

frontend/src/api/types.ts

@@ -114,7 +114,7 @@ export type Artifact = {
   type: ArtifactType;
   type_label: string;
   title: string;
-  status: "pending" | "generating" | "rendering" | "ready" | "failed" | "draft";
+  status: "pending" | "generating" | "rendering" | "review" | "ready" | "failed" | "draft";
   notebook_id: string | null;
   document_id: string | null;
   content: Record<string, any>;
@@ -124,6 +124,8 @@ export type Artifact = {
   slide_urls: string[];
   created_at: string | null;
   job: Job | null;
+  /** "blog2video" for videos made in the Videos editor. */
+  provider?: string | null;
 };
 
 export type TopicStatus = "rising" | "steady" | "dormant";
@@ -301,7 +303,8 @@ export type Plan = {
   sources: number;
   indexed_posts: number;
   audio_minutes: number;
-  video_minutes: number;
+  /** blog2video videos per period */
+  videos: number;
   launch_kits: number;
   voice_cloning: boolean;
   brand_kit: boolean;
@@ -309,8 +312,9 @@ export type Plan = {
 
 export type Usage = {
   plan: string;
-  used: { audio_minutes: number; video_minutes: number; launch_kits: number; llm_tokens: number; since: string };
-  limits: { audio_minutes: number; video_minutes: number; launch_kits: number; sources: number; indexed_posts: number };
+  used: { audio_minutes: number; videos: number; launch_kits: number; llm_tokens: number; since: string };
+  limits: { audio_minutes: number; videos: number; launch_kits: number; sources: number; indexed_posts: number };
+  videos_resets_at: string | null;
 };
 
 export type Settings = {
@@ -355,5 +359,295 @@ export type BillingStatus = {
   period_end: string | null;
   meters: Meter[];
   since: string;
+  /** Videos reset on renewal (or monthly without one), not on the 1st like the other meters. */
+  videos_resets_at: string | null;
   nudges: Nudge[];
 };
+
+// Videos (blog2video). Everything goes through our API; ids are our artifact ids unless named b2v/custom.
+
+export type VideoLimitMetric =
+  | "ai_edits" | "templates" | "template_ai_daily" | "voice_designs_daily" | "voice_samples_daily" | "custom_voices";
+
+export type VideoConfig = {
+  configured: boolean;
+  /** Premium (★) video options are included in this workspace's plan. */
+  premium: boolean;
+  limits: Record<VideoLimitMetric, { used: number; limit: number }>;
+};
+
+/** A row on the Videos page. */
+export type VideoListItem = Artifact & {
+  source_url: string | null;
+  scenes: number | null;
+  /** blog2video's own status: generated, done, awaiting_script_review, ... */
+  b2v_status: string | null;
+};
+
+export type VideoQuota = { used: number; limit: number; plan: string; period_start: string | null; resets_at: string | null };
+
+export type VideoTemplate = {
+  id: string;
+  name: string;
+  description?: string;
+  preview_url?: string | null;
+  /** The 9:16 poster, for portrait videos. */
+  preview_portrait_url?: string | null;
+  genres?: string[];
+  badge?: string | null;
+  popular_template?: boolean;
+  new_template?: boolean;
+  preview_colors?: { accent?: string; bg?: string; text?: string };
+  /** One of this workspace's own custom templates. */
+  custom?: boolean;
+};
+
+export type VideoStyleItem = {
+  /** "auto" | "explainer" | "storytelling" | "promotional" | "custom:<id>" */
+  id: string;
+  name: string;
+  description?: string | null;
+  kind: "builtin" | "custom";
+  custom_id?: number;
+  guidance?: string | null;
+  version?: number;
+};
+
+export type MusicTrack = { track_id: string; display_name: string; mood?: string; r2_url?: string | null };
+
+export type VideoCatalog = {
+  templates: VideoTemplate[];
+  crafted_templates: VideoTemplate[];
+  my_templates: VideoTemplate[];
+  video_styles: VideoStyleItem[];
+  music: MusicTrack[];
+  languages: { code: string; name: string }[];
+};
+
+/** A voice in the workspace's "My voices" list (kept only in Notestack). */
+export type VideoSavedVoice = {
+  voice_id: string;
+  name: string;
+  preview_url: string | null;
+  gender: string | null;
+  accent: string | null;
+  premium: boolean;
+  is_custom: boolean;
+};
+
+export type VideoLibraryVoice = {
+  voice_id: string;
+  name: string;
+  description: string;
+  preview_url: string | null;
+  gender: string | null;
+  accent: string | null;
+  age?: string | null;
+  premium: boolean;
+  saved: boolean;
+};
+
+export type VideoCustomVoice = {
+  id: number;
+  voice_id: string;
+  name: string;
+  source: "prompt" | "preset" | "clone";
+  preview_url: string | null;
+  saved: boolean;
+};
+
+export type VideoVoicesResponse = { saved: VideoSavedVoice[]; library: VideoLibraryVoice[]; custom: VideoCustomVoice[] };
+
+export type VideoDesignedVoice = {
+  generated_voice_id: string;
+  audio_base_64: string;
+  media_type: string;
+  duration_secs: number;
+};
+
+export type VideoLength = "short" | "medium" | "detailed" | "more_detailed";
+export type LogoPosition = "bottom_right" | "bottom_left" | "top_left" | "top_right";
+
+/** Every field of the 3-step wizard, named as blog2video names them. */
+export type VideoOptions = {
+  // Step 1: Project
+  stock_footage_enabled: boolean;
+  aspect_ratio: "landscape" | "portrait";
+  video_length: VideoLength;
+  logo_upload_id?: string;
+  logo_position: LogoPosition;
+  logo_opacity: number;
+  // Step 2: Template
+  template: string;
+  video_style: string;
+  accent_color?: string;
+  bg_color?: string;
+  text_color?: string;
+  // Step 3: Voice
+  content_language?: string | null;
+  voice_gender: "female" | "male" | "none";
+  voice_accent: string;
+  custom_voice_id?: string;
+  voice_emotion?: string;
+  bgm_track_id?: string;
+  bgm_volume: number;
+};
+
+export type VideoCreateBody = VideoOptions & {
+  document_id?: string;
+  /** A notebook's ticked posts, combined into one video. */
+  document_ids?: string[];
+  /** Names a combined video after its notebook. */
+  notebook_id?: string;
+  url?: string;
+  content?: string;
+  title?: string;
+};
+
+export type VideoStatus = {
+  video_id: number;
+  status: string;
+  step: number | null;
+  running: boolean;
+  ready: boolean;
+  error: string | null;
+  video_url: string | null;
+  artifact_status: Artifact["status"];
+  /** Made through the old partner integration: blog2video can no longer reach it, so only stored links remain. */
+  legacy?: true;
+};
+
+export type VideoScene = {
+  id: number;
+  order: number;
+  title: string;
+  display_text: string | null;
+  narration_text: string;
+  visual_description?: string;
+  preferred_layout?: string | null;
+  duration_seconds: number;
+  voiceover_path?: string | null;
+  avatar_video_path?: string | null;
+  bgm_volume?: number | null;
+  extra_hold_seconds?: number | null;
+  /** JSON: {"layout": ..., "layoutProps": {...}} (layoutConfig on custom templates). */
+  remotion_code?: string | null;
+  // Worked out by our backend (routers/videos.py _enrich)
+  audio_url?: string | null;
+  images?: { filename: string; asset_id: number | null; kind: string; url: string }[];
+  layout?: string | null;
+  title_font_size?: number | null;
+  desc_font_size?: number | null;
+  [key: string]: unknown;
+};
+
+export type VideoAsset = {
+  id: number;
+  asset_type: string;
+  r2_url: string | null;
+  filename: string;
+  excluded: boolean;
+  duration_seconds?: number | null;
+  source_provider?: string | null;
+};
+
+/** blog2video's project, as its editor sees it. */
+export type VideoProjectData = {
+  id: number;
+  name: string;
+  status: string;
+  template: string;
+  aspect_ratio: "landscape" | "portrait";
+  accent_color: string;
+  bg_color: string;
+  text_color: string;
+  font_family: string | null;
+  voice_gender: string;
+  voice_accent: string;
+  custom_voice_id: string | null;
+  content_language: string | null;
+  logo_r2_url: string | null;
+  logo_position: string;
+  logo_opacity: number;
+  logo_size: number;
+  bgm_track_id: string | null;
+  bgm_volume: number;
+  playback_speed: number;
+  captions_enabled: boolean;
+  caption_position: string;
+  caption_font_family?: string | null;
+  caption_font_size?: number | string | null;
+  /** -100 (down) to 100 (up); 0 is the template's default place. */
+  caption_offset?: number | null;
+  r2_video_url: string | null;
+  scenes: VideoScene[];
+  assets: VideoAsset[];
+  summary?: { scenes: number; images: number; clips?: number; duration_seconds: number };
+  [key: string]: unknown;
+};
+
+/** A video made before the switch to our API key: stored links only, no edits. */
+export type LegacyVideo = {
+  legacy: true;
+  status: string | null;
+  ready: boolean;
+  preview_url: string | null;
+  video_url: string | null;
+  artifact: Artifact;
+};
+
+export type VideoProject = {
+  legacy?: undefined;
+  video_id: number;
+  status: string;
+  preview_url: string | null;
+  video_url: string | null;
+  project: VideoProjectData;
+  artifact: Artifact;
+};
+
+/** Background jobs (template, voice, language, add scene, render, script refresh) report progress in roughly this
+ *  shape; each names things slightly differently. */
+export type VideoJobState = { status?: string; running?: boolean; done?: boolean; error?: string | null;
+                              progress?: number; video_url?: string | null; [key: string]: unknown };
+
+export type ScriptScene = {
+  id: number;
+  order: number;
+  title: string;
+  display_text: string | null;
+  narration_text: string;
+  preferred_layout?: string | null;
+};
+
+export type ScriptPreview = { revision: number; title: string; display_text: string; narration_text: string;
+                              source_fingerprint: string };
+
+// Custom templates
+
+export type MyTemplate = { id: number; ref: string; name: string; ready: boolean; created_at: string | null };
+
+export type TemplatesResponse = {
+  templates: MyTemplate[];
+  limits: Record<"templates" | "template_ai_daily", { used: number; limit: number }>;
+};
+
+export type ExtractedTheme = {
+  extractable: boolean;
+  reason: string;
+  theme: Record<string, unknown> | null;
+  template_name: string;
+  logo_urls: string[];
+  og_image: string;
+  screenshot_url: string;
+};
+
+export type TemplateGeneration = {
+  status: string;
+  step?: string | null;
+  running: boolean;
+  error: string | null;
+  scenes_done?: number;
+  scenes_total?: number;
+  ready: boolean;
+};

frontend/src/components/AppShell.tsx

@@ -8,6 +8,7 @@ import SkyCanvas from "./SkyCanvas";
 import UpgradeModal from "./UpgradeModal";
 import {
   AsteroidIcon,
+  CometIcon,
   HelmetIcon,
   LaunchpadIcon,
   LaunchWindowIcon,
@@ -18,12 +19,13 @@ import {
 } from "./icons/Icons";
 
 // Theme in the icon, clarity in the label: the plain label always shows.
-// Seven stops: related pages share one entry (`also` keeps it lit on them).
+// Eight stops: related pages share one entry (`also` keeps it lit on them).
 const NAV: { to: string; label: string; icon: typeof RadarIcon; end?: boolean; also?: string[] }[] = [
   { to: "/app", label: "Home", icon: RadarIcon, end: true },
   { to: "/app/sources", label: "Sources", icon: SatelliteDishIcon, also: ["/app/map"] },
   { to: "/app/notebooks", label: "Notebooks", icon: PlanetIcon },
   { to: "/app/studio", label: "Create", icon: LaunchWindowIcon, also: ["/app/launch-kit"] },
+  { to: "/app/videos", label: "Videos", icon: CometIcon },
   { to: "/app/launchpad", label: "Launchpad", icon: LaunchpadIcon, also: ["/app/resurface"] },
   { to: "/app/archive", label: "Library", icon: AsteroidIcon },
   { to: "/app/voice", label: "Voice", icon: HelmetIcon },