@gentbajko/slopify 3.0.14 → 3.1.0

package/dist/edge/http/schedules.js

@@ -3,6 +3,7 @@ import { Hono } from "hono";
 import { HTTPException } from "hono/http-exception";
 import { z } from "zod";
 import { calendarRange } from "../../slices/schedules/agenda.js";
+import { preparedTopics, prepareTopic } from "../../slices/schedules/prepare.js";
 import { calendarMaxDays, calendarSchema, heldTopicEditSchema, heldTopicSchema, queueMax, scheduleCreateSchema, scheduleRunSchema, scheduleSummarySchema, scheduleUpdateSchema, topicMoveSchema, topicQueueSchema, topicTransferSchema, } from "../../slices/schedules/schema.js";
 import { cancelSchedule, createSchedule, deleteSchedule, listScheduleRuns, listSchedules, pauseSchedule, resumeSchedule, updateSchedule, } from "../../slices/schedules/service.js";
 import { approveHeldTopics, editHeldTopic, heldTopics, moveTopic, rejectHeldTopic, replaceTopics, transferTopic, } from "../../slices/schedules/topics.js";
@@ -118,6 +119,32 @@ function routes(deps) {
         return c.json({
             topics: heldTopics(service(), scheduleId).map((topic) => heldTopicSchema.parse(topic)),
         });
+    })
+        // Which queued topics are prepared ahead, and their projects.
+        .get("/:id/prepared", zValidator("param", id, onInvalid), (c) => c.json({ prepared: preparedTopics(service(), c.req.valid("param").id) }))
+        // Prepare one queued topic now: everything but the video, which its scheduled day renders.
+        .post("/:id/topics/prepare", zValidator("param", id, onInvalid), zValidator("json", z.object({ topic: z.string().min(1).max(500) }).strict(), onInvalid), async (c) => {
+        const result = await prepareTopic(service(), {
+            scheduleId: c.req.valid("param").id,
+            title: c.req.valid("json").topic,
+        });
+        if (result.ok)
+            return c.json({ projectId: result.projectId, title: result.title }, 201);
+        const detail = {
+            "not-found": "This topic is no longer in the schedule's queue. Reload the page to see the queue as it is now.",
+            "already-prepared": "This topic is already prepared: its project is in Projects under the same title.",
+            "missing-template": "This schedule's template was deleted, so there is nothing to prepare from. Choose another template under Edit.",
+            "spend-limit": "Preparing it would go over this schedule's spend limit. Raise the limit under Edit, or prepare it from Play instead.",
+        };
+        return problem(c, {
+            status: result.reason === "not-found" ? 404 : 409,
+            title: titleOf(result.reason === "not-found" ? 404 : 409),
+            detail: detail[result.reason] ??
+                (result.detail === undefined
+                    ? `This topic couldn't be prepared (${result.reason}). Open Play with the schedule's template to see what the setup needs, then try again.`
+                    : `This topic couldn't be prepared: ${result.detail} Fix it in the schedule's template (Library → Templates), then try again.`),
+            extensions: { reason: result.reason },
+        });
     })
         // Starts a generation in the background; the schedule's `topics` says when it is done.
         .post("/:id/topics/generate", zValidator("param", id, onInvalid), (c) => {

package/dist/kernel/db/migrations/0043-prepared-videos.sql

@@ -0,0 +1,13 @@
+-- A schedule's topic prepared ahead (Schedules → a topic → Prepare): its project runs everything
+-- but the video now and holds at a Before Video checkpoint; on the scheduled day the schedule
+-- continues it instead of starting another. `added_checkpoint` says the hold is the preparation's
+-- own, so the day releases it; a Before Video checkpoint the template already had stays for the
+-- person to approve.
+CREATE TABLE prepared_videos (
+ project_id TEXT PRIMARY KEY REFERENCES projects(id) ON DELETE CASCADE,
+ schedule_id TEXT NOT NULL,
+ title TEXT NOT NULL,
+ added_checkpoint INTEGER NOT NULL CHECK (added_checkpoint IN (0, 1)),
+ prepared_at TEXT NOT NULL
+);
+CREATE INDEX prepared_videos_title ON prepared_videos(schedule_id, title);

package/dist/patch-notes/3.0.15.md

@@ -0,0 +1,17 @@
+# Slopify 3.0.15
+
+Released 30 September 2026.
+
+3.0.15 makes a garbled narration chunk get recorded again even when the project is busy.
+
+## Fixes
+
+- When the captions caught a garbled sentence, Slopify said it was recording that narration chunk again, but if another step of the project was still running at that moment (its PDF, say), the retry gave up and the video stayed failed. The retry now waits for that step and starts as soon as it finishes.
+
+## Under the hood
+
+- Faster CI and releases: Docker images build beside the npm publish, the Windows install check uses one warm cache, and unchanged Windows and Docker checks are skipped.
+
+## Upgrading from 3.0.14
+
+- **Nothing becomes outdated.**

package/dist/patch-notes/3.1.0.md

@@ -0,0 +1,28 @@
+# Slopify 3.1.0
+
+Released 30 September 2026.
+
+3.1.0 lets a schedule's videos be made ahead of their day, and several videos from one Start run together.
+
+## Highlights
+
+- **Prepare a scheduled video ahead.** Everything but the video is made now; its scheduled day only renders.
+- **Run several videos at once.** Play's Queue switch: on, one after another; off, all together.
+
+## Schedules and the calendar
+
+- Every queued run on the calendar has **Prepare**. Slopify makes the project now, exactly as the schedule would on the day (the template as it is now, the topic and the schedule's values), and runs research, the article, narration, images, the thumbnail and the PDF. It holds before the video, and the run shows **Prepared** with **Open**.
+- On the scheduled day the schedule continues that project instead of making another: the video, its captions, shorts and YouTube description are made. An unfinished project you made yourself under the same title is continued the same way; a finished or canceled one is not.
+- Open a prepared project to read the article or listen to the narration, and change anything before its day. A Before Video checkpoint the template already has still waits for you.
+
+## Play
+
+- With more than one video, the Start box has a **Queue** switch (on by default). Off, they all start at once as separate runs, and the Play key reads **Start N videos**. At once finishes sooner while steps wait on providers, but the renders share your processor and plan limits are reached sooner.
+
+## Fixes
+
+- **Review** refused any setup with burned-in captions and a Before Video checkpoint ("Something changed since you reviewed this video"), however often you pressed it.
+
+## Upgrading from 3.0.15
+
+- **Nothing becomes outdated.** The database gains one table, for prepared videos.

package/dist/patch-notes/index.json

@@ -1,4 +1,16 @@
 [
+  {
+    "id": "3.1.0",
+    "title": "Slopify 3.1.0",
+    "version": "3.1.0",
+    "date": "2026-09-30"
+  },
+  {
+    "id": "3.0.15",
+    "title": "Slopify 3.0.15",
+    "version": "3.0.15",
+    "date": "2026-09-30"
+  },
   {
     "id": "3.0.14",
     "title": "Slopify 3.0.14",

package/dist/slices/play-drafts/review.js

@@ -51,7 +51,14 @@ export async function resolvePlayReview(deps, view) {
     }
     if (fields.length)
         return reviewRefusal(view, fields);
-    return reviewBinding(before.value) === reviewBinding(after.value)
+    // Did anything change while the font and the models were looked up? Both sides are resolved
+    // without the font: `before` had none yet, and a Before Video checkpoint covers the render
+    // that burns the captions in, so comparing it with `after` always differed and refused every
+    // such review.
+    const unchanged = resolveReviewInputs(deps, parsed.data, null);
+    if (!unchanged.ok)
+        return unchanged;
+    return reviewBinding(before.value) === reviewBinding(unchanged.value)
         ? after
         : reviewRefusal(view, [], "stale-review");
 }

package/dist/slices/play-drafts/schema.js

@@ -226,6 +226,9 @@ export const playDraftDocumentSchema = z
     form: playDraftFormSchema,
     section: z.enum(["content", "outputs", "style", "review"]),
     variants: z.array(z.object({ id, title: text, values }).strict().readonly()).readonly(),
+    // Several videos from one Start: queued (one after another, the default) or all started
+    // together. Absent reads as queued, as every draft saved before the choice was.
+    queue: z.boolean().optional(),
     expectedWords: text,
     previewText: text,
     fontUpload: z.object({ operationId: id, name: text }).strict().readonly().nullable(),

package/dist/slices/play-drafts/start.js

@@ -137,10 +137,14 @@ function createReviewedRuns(deps, input, captured, checked, catalogue) {
         const first = runs[0];
         if (!first)
             throw new Error("Reviewed run list was empty");
-        const queue = runs.length === 1 ? [] : enqueueBatch(captured, input.reviewId, runs, true);
-        const projectIds = runs.length === 1
-            ? [startRun(captured, first.draft, first.rendered, true, first.templates).project.id]
-            : queue.map((e) => e.projectId);
+        // Several videos run one after another (a batch queue) unless the draft asks for them
+        // all at once (Play → Queue off): then each starts as its own run.
+        const view = readDraft(deps, input.draftId);
+        const queued = runs.length > 1 && (!view.ok || view.value.draft.document.queue !== false);
+        const queue = queued ? enqueueBatch(captured, input.reviewId, runs, true) : [];
+        const projectIds = queued
+            ? queue.map((e) => e.projectId)
+            : runs.map((run) => startRun(captured, run.draft, run.rendered, true, run.templates).project.id);
         const checkpointSet = admitReviewedCheckpoints(captured, projectIds, starting.value.checkpointSet ?? [], catalogue);
         const value = {
             requestId: input.reviewId,
@@ -149,7 +153,7 @@ function createReviewedRuns(deps, input, captured, checked, catalogue) {
             replayed: false,
             ...(checkpointSet.length ? { checkpointSet } : {}),
         };
-        if (projectIds.length !== runs.length || queue.length !== (runs.length === 1 ? 0 : runs.length))
+        if (projectIds.length !== runs.length || queue.length !== (queued ? runs.length : 0))
             throw new StartedRunMismatch(`Start would create ${projectIds.length} of ${runs.length} reviewed videos (${queue.length} queued).`);
         insertStartReceipt(deps, input, value);
         markDraftStartedAndReleaseRefs(deps.db, input);

package/dist/slices/rebuild/narration-retry.js

@@ -105,6 +105,16 @@ async function recordAgain(deps, retry) {
             detail: `Recording ${retry.chunkKey} again (try ${String(retry.tries)} of ${String(narrationRetryLimit)}).`,
         });
     }
+    else if (result.reason === "running") {
+        // Another step of the project is still going (its PDF, say): the retry waits for it and
+        // starts when that step finishes, which kicks this again (`onFinished`). Giving up here
+        // left the video failed with a message promising a retry that never came.
+        deps.log.write("info", "narration.retry", {
+            projectId: retry.projectId,
+            detail: `Recording ${retry.chunkKey} again once the project's running steps finish.`,
+        });
+        return;
+    }
     else {
         settle(deps.db, retry, "failed", refusal(result), now);
         deps.log.write("warn", "narration.retry", {

package/dist/slices/schedules/agenda.js

@@ -7,6 +7,7 @@ import { readSampleRecord } from "../onboarding/state.js";
 import { limitWaitsByProject, listingWait } from "../run-cost/panel.js";
 import { uploadedProjects } from "../uploads/repo.js";
 import { nextOccurrence } from "./calendar.js";
+import { preparedProject } from "./prepare.js";
 import { scheduleRows } from "./repo.js";
 import { calendarMaxDays, } from "./schema.js";
 import { renderedTitle } from "./topic-list.js";
@@ -66,6 +67,7 @@ function upcomingRuns(deps, schedule, now, from, to) {
         // Known for a queued topic, and for a run of the template as saved; a held or generated
         // topic has no text yet.
         const known = queuedTopic !== undefined || generation === "off";
+        const title = form !== undefined && known ? renderedTitle(form, schedule, queuedTopic) : null;
         if (at >= from)
             runs.push({
                 at: at.toISOString(),
@@ -85,7 +87,11 @@ function upcomingRuns(deps, schedule, now, from, to) {
                         : k < items.length + held
                             ? "held"
                             : "generated",
-                renderedTitle: form !== undefined && known ? renderedTitle(form, schedule, queuedTopic) : null,
+                renderedTitle: title,
+                // Prepared ahead (`prepare.ts`): the project the day continues.
+                prepared: title === null || queuedTopic === undefined
+                    ? null
+                    : (preparedProject(deps.db, schedule.id, title)?.projectId ?? null),
             });
         if (schedule.cadence.kind === "once")
             break;

package/dist/slices/schedules/prepare.js

@@ -0,0 +1,147 @@
+import { derive } from "../../kernel/runner/graph.js";
+import { projectPaused, stagesOf } from "../admission/repo.js";
+import { changeCheckpoints } from "../checkpoints/change.js";
+import { listCheckpoints } from "../checkpoints/repo.js";
+import { reviewDraft } from "../play-drafts/review.js";
+import { createDraft } from "../play-drafts/service.js";
+import { startPlayDraft } from "../play-drafts/start.js";
+import { freshTemplateDraft } from "../project-templates/setup.js";
+import { currentRevisionId } from "../revisions/repo.js";
+import { scheduleById } from "./repo.js";
+import { renderedTitle, scheduledValues } from "./topic-list.js";
+// The draft a schedule's run starts for one topic: the template as it is now, the topic in its
+// keyword, the schedule's values over the template's, and the title filled from them.
+export function scheduledDocument(deps, schedule, topic) {
+    const template = deps.template(schedule.templateId);
+    if (template === undefined)
+        return undefined;
+    const document = freshTemplateDraft(deps, template.document, {
+        id: schedule.templateId,
+        version: template.version,
+    });
+    return {
+        ...document,
+        form: {
+            ...document.form,
+            title: renderedTitle(document.form, schedule, topic),
+            values: scheduledValues(document.form, schedule, topic),
+        },
+        variants: [],
+    };
+}
+export async function prepareTopic(deps, input) {
+    const schedule = scheduleById(deps.db, input.scheduleId);
+    if (schedule === undefined)
+        return { ok: false, reason: "not-found" };
+    const topic = schedule.items.find((item) => item.title === input.title);
+    if (topic === undefined)
+        return { ok: false, reason: "not-found" };
+    const document = scheduledDocument(deps, schedule, topic);
+    if (document === undefined)
+        return { ok: false, reason: "missing-template" };
+    const title = document.form.title;
+    if (preparedProject(deps.db, schedule.id, title) !== undefined)
+        return { ok: false, reason: "already-prepared" };
+    const { document: held, added } = heldBeforeVideo(document);
+    const draft = createDraft(deps, { id: deps.uuid(), document: held });
+    if (!draft.ok)
+        return { ok: false, reason: "conflict" };
+    const review = await reviewDraft(deps, { id: draft.value.draft.id, baseVersion: 1 });
+    if (!review.ok)
+        return {
+            ok: false,
+            reason: review.reason,
+            // What the setup needs, as Play would say it ("This font was deleted. Choose another font.").
+            ...(review.fields.length === 0
+                ? {}
+                : { detail: review.fields.map((field) => field.message).join(" ") }),
+        };
+    const high = review.value.estimates.reduce((sum, estimate) => sum + estimate.high, 0);
+    if (schedule.spendLimitCents !== null &&
+        (review.value.estimates.some((estimate) => estimate.unknown > 0) ||
+            high * 100 > schedule.spendLimitCents))
+        return { ok: false, reason: "spend-limit" };
+    const started = await startPlayDraft(deps, {
+        draftId: draft.value.draft.id,
+        baseVersion: 1,
+        reviewId: review.value.id,
+    });
+    if (!started.ok)
+        return { ok: false, reason: started.reason };
+    const projectId = started.value.projectIds[0];
+    if (projectId === undefined)
+        return { ok: false, reason: "conflict" };
+    deps.db
+        .prepare("INSERT INTO prepared_videos(project_id,schedule_id,title,added_checkpoint,prepared_at) VALUES (?,?,?,?,?)")
+        .run(projectId, schedule.id, title, added ? 1 : 0, deps.clock.now().toISOString());
+    return { ok: true, projectId, title };
+}
+// The draft with a Before Video checkpoint, and whether it is the preparation's own. A project
+// that makes no video has nothing to hold back: it runs to the end when prepared.
+export function heldBeforeVideo(document) {
+    const had = document.form.checkpoints ?? [];
+    if (document.form.sources.video !== "generate" || had.includes("video"))
+        return { document, added: false };
+    return {
+        document: { ...document, form: { ...document.form, checkpoints: [...had, "video"] } },
+        added: true,
+    };
+}
+const ended = new Set(["done", "partial", "failed", "canceled"]);
+// The project a scheduled run of this title continues: one prepared for it, or else, for a run
+// with a topic, an unfinished project of the same title (made by hand, say). A finished one is
+// a video already made, and a new run makes a new one. A schedule without topics gives every
+// run the same title, so only a prepared project counts there.
+export function preparedProject(db, scheduleId, title, byTitle = true) {
+    const live = "project_id NOT IN (SELECT project_id FROM project_trash)";
+    const prepared = db
+        .prepare(`SELECT project_id, added_checkpoint FROM prepared_videos
+       WHERE schedule_id=? AND title=? AND ${live} ORDER BY prepared_at DESC LIMIT 1`)
+        .get(scheduleId, title);
+    // A prepared project canceled since is no video to continue: the day makes a new one.
+    if (typeof prepared?.project_id === "string" &&
+        derive(stagesOf(db, prepared.project_id), projectPaused(db, prepared.project_id)) !== "canceled")
+        return { projectId: prepared.project_id, release: prepared.added_checkpoint === 1 };
+    if (!byTitle)
+        return undefined;
+    for (const row of db
+        .prepare("SELECT id FROM projects WHERE title=? AND id NOT IN (SELECT project_id FROM project_trash) ORDER BY created_at DESC")
+        .all(title)) {
+        const id = String(row.id);
+        if (!ended.has(derive(stagesOf(db, id), projectPaused(db, id))))
+            return { projectId: id, release: false };
+    }
+    return undefined;
+}
+// The scheduled day for a prepared video: its own Before Video hold is taken away, so the
+// video renders as soon as what it needs is done. A Before Video checkpoint the template had
+// stays for the person to approve.
+export function continuePrepared(deps, prepared) {
+    if (prepared.release) {
+        const head = currentRevisionId(deps.db, prepared.projectId);
+        if (head !== undefined) {
+            const stages = listCheckpoints(deps.db, prepared.projectId, head)
+                .map((row) => row.stage)
+                .filter((stage) => stage !== "video");
+            changeCheckpoints(deps, { projectId: prepared.projectId, revisionId: head, stages });
+        }
+    }
+    // Continued once: the topic is used, and the project is now the run's.
+    deps.db.prepare("DELETE FROM prepared_videos WHERE project_id=?").run(prepared.projectId);
+    deps.runner.tick(prepared.projectId);
+}
+// Which of a schedule's topics are prepared, and their projects, for the topic list.
+export function preparedTopics(deps, scheduleId) {
+    const schedule = scheduleById(deps.db, scheduleId);
+    if (schedule === undefined)
+        return [];
+    return schedule.items.flatMap((topic) => {
+        const document = scheduledDocument(deps, schedule, topic);
+        if (document === undefined)
+            return [];
+        const found = preparedProject(deps.db, scheduleId, document.form.title);
+        return found === undefined
+            ? []
+            : [{ title: document.form.title, topic: topic.title, projectId: found.projectId }];
+    });
+}

package/dist/slices/schedules/scheduler.js

@@ -2,10 +2,9 @@ import { transact } from "../../kernel/db/tx.js";
 import { reviewDraft } from "../play-drafts/review.js";
 import { createDraft } from "../play-drafts/service.js";
 import { startPlayDraft } from "../play-drafts/start.js";
-import { freshTemplateDraft } from "../project-templates/setup.js";
 import { nextOccurrence } from "./calendar.js";
+import { continuePrepared, preparedProject, scheduledDocument } from "./prepare.js";
 import { activeRun, dueSchedules, insertRun, recordRunDispatch, recordRunStartIdentity, recoverRunningRuns, scheduleById, scheduleRows, updateRun, } from "./repo.js";
-import { renderedTitle, scheduledValues } from "./topic-list.js";
 import { generateTopics, generationDue, releaseTopicLeases } from "./topics.js";
 const missedGraceMs = 60_000;
 export function createScheduleRunner(deps) {
@@ -134,19 +133,20 @@ async function execute(deps, claimed) {
     let run = claimed.run;
     try {
         // The template as it is now, so an edit to it reaches the next run.
-        const template = deps.template(claimed.schedule.templateId);
-        if (template === undefined)
-            throw new ScheduleDispatchError("missing-template");
-        const document = freshTemplateDraft(deps, template.document, {
-            id: claimed.schedule.templateId,
-            version: template.version,
-        });
         const topic = claimed.schedule.items[0];
-        const fresh = {
-            ...document,
-            form: runForm(document.form, claimed.schedule, topic),
-            variants: [],
-        };
+        const fresh = scheduledDocument(deps, claimed.schedule, topic);
+        if (fresh === undefined)
+            throw new ScheduleDispatchError("missing-template");
+        // Prepared ahead (`prepare.ts`), or made by hand under the same title: continue it rather
+        // than make the same video twice.
+        const prepared = preparedProject(deps.db, claimed.schedule.id, fresh.form.title, topic !== undefined);
+        if (prepared !== undefined) {
+            continuePrepared(deps, prepared);
+            run = { ...run, projectIds: [prepared.projectId] };
+            recordRunDispatch(deps.db, run, deps.clock.now().toISOString(), topic);
+            updateRun(deps.db, { ...run, status: "succeeded", endedAt: deps.clock.now().toISOString() });
+            return;
+        }
         const draft = createDraft(deps, { id: deps.uuid(), document: fresh });
         if (!draft.ok)
             throw new ScheduleDispatchError("conflict");
@@ -193,17 +193,6 @@ async function execute(deps, claimed) {
     }
     updateRun(deps.db, run);
 }
-// One project per run. The first queued topic fills the chosen keyword, the schedule's fixed
-// values fill the rest over the template's own, and the template's title is filled from the
-// same keywords, so "History: {{Topic}}" names the project after the topic. A topic saved
-// before topics had a keyword brings its own title and values instead.
-function runForm(form, schedule, topic) {
-    return {
-        ...form,
-        title: renderedTitle(form, schedule, topic),
-        values: scheduledValues(form, schedule, topic),
-    };
-}
 class ScheduleDispatchError extends Error {
     reason;
     constructor(reason) {

package/dist/slices/schedules/schema.js

@@ -207,6 +207,9 @@ export const calendarRunSchema = z
     // be known yet (a topic still to be approved or generated, or a deleted template). Older
     // servers leave it out.
     renderedTitle: z.string().nullable().default(null),
+    // The project prepared ahead for this run (Prepare), which its day continues. Older servers
+    // leave it out.
+    prepared: z.string().nullable().default(null),
 })
     .strict()
     .readonly();

package/dist/slices/storage/backup-format.js

@@ -58,6 +58,7 @@ export const projectTables = [
     // Since 2.5.0. Left out on purpose: plan_limit_waits and plan_limit_waiters (an account's
     // current wait, a lease of this install) and prompt_softening (a pending one-off request).
     // Since 3.0.8, narration_retries is left out too: the tries of a run, not of the project.
+    // Since 3.1.0, prepared_videos too: a schedule's hold on this install's next run.
     "review_verdicts",
     "provider_usage",
     "plan_limit_readings",

package/dist/tutorials/Calendar.md

@@ -16,6 +16,8 @@ The calendar starts on this week's Monday and shows four weeks, Monday to Sunday
 
 The calendar follows the channel picked in the sidebar, or shows every channel. See [Channels](Channels).
 
+Each queued run has **Prepare**, which makes its video ahead of the day and leaves only the render for the day; a prepared run shows **Prepared** and **Open**. See [Schedules](Schedules#prepare-a-video-ahead).
+
 ## Needs you
 
 Above the weeks, **Needs you** lists what cannot move on without you, then what is ready to upload. Its heading counts them, for example "2 waiting for you · 1 ready to upload". It is hidden when there is nothing.

package/dist/tutorials/Play-Overview.md

@@ -75,7 +75,18 @@ Keywords live in the **Title and keywords** row. Topic keywords (the ones the ti
 3. Each extra video shows as a chip. Its name is a button with a pencil (**Change the keywords of …**): press it to open a side panel where you can change that video's **Title** and keywords. Everything else comes from the setup of the first video.
 4. Press the **x** on a chip to remove that video.
 
-One Start queues at most 50 videos: this setup and 49 more. The Play key reads **Queue N videos**, and the videos run one at a time, in order.
+One Start makes at most 50 videos: this setup and 49 more.
+
+### Queue or all at once
+
+With more than one video, the Start box has a **Queue** switch (on by default):
+
+| Queue | What happens | The Play key reads |
+| --- | --- | --- |
+| **On** | The videos run one after another, in order, each starting when the one before finishes. | **Queue N videos** |
+| **Off** | They all start at once, as separate runs. | **Start N videos** |
+
+All at once finishes sooner while the steps wait on providers (research, narration, images), but the video renders share your computer's processor, so each renders slower, and Claude or Codex plan limits are reached sooner (Slopify waits and goes on when they are).
 
 ### The video queue
 

package/dist/tutorials/Schedules.md

@@ -83,6 +83,23 @@ Pick a schedule in the list to see its **Queued topics · N**. You can change th
 
 Each change saves at once and says so, for example "Renamed to “Hypatia of Alexandria”.", with **Undo** on the notice. Only the queue changes; the next run and the other settings stay as they are. If the schedule changed in another tab meanwhile, the change is refused with the reason; reload and try again.
 
+## Prepare a video ahead
+
+A scheduled video can be made ahead of its day, so the day only renders it: useful before a trip, or to read the article and listen to the narration first.
+
+1. Open **Calendar** and find the topic's run (either view).
+2. Press **Prepare**.
+
+Slopify makes the project now, exactly as the schedule would on the day (the template as it is now, the topic and the schedule's values), and runs everything but the video: research, the article, narration, images, the thumbnail and the PDF. It then holds at a **Before Video** checkpoint, and the run shows **Prepared** with **Open**.
+
+On the scheduled day the schedule finds that project by its title and continues it instead of making another: the hold is lifted and the video, its captions, shorts and YouTube description are made. The same goes for an unfinished project you made yourself under the same title. A finished one counts as a video already made, and the day makes a new one.
+
+- You can open the prepared project and change anything before its day, for example with Edit project.
+- A **Before Video** checkpoint the template already has stays: the day waits for you to approve it.
+- A setup that makes no video has nothing to hold back, so Prepare runs it to the end.
+- A schedule without topics gives every run the same title, so only a prepared project continues there.
+- The spend limit applies to Prepare as it does to a scheduled run.
+
 ## Topics that find themselves
 
 Under **Topic generation**, a schedule can ask an LLM for its next topics so it never runs dry.