@gentbajko/slopify 2.5.0 → 3.0.1

package/dist/slices/revisions/adopt.js

@@ -14,7 +14,8 @@ export function ensureBaseline(deps, projectId) {
     return withProjectControl(deps.db, projectId, () => adoptBaseline(deps, projectId));
 }
 export function adoptBaseline(deps, projectId, templates, 
-// The Shorts step's background music a new run was started with, already a project asset.
+// The Shorts step's background music and the ambient bed's own file a new run was started
+// with, already project assets.
 supplied = {}) {
     return transact(deps.db, () => {
         const project = projectById(deps.db, projectId);
@@ -34,6 +35,7 @@ supplied = {}) {
         const content = {
             ...baselineContent(deps, project, outputs, pieces, assets, templates),
             ...(supplied.shortsMusic === undefined ? {} : { shortsMusic: supplied.shortsMusic }),
+            ...(supplied.ambientBed === undefined ? {} : { ambientBed: supplied.ambientBed }),
         };
         const fingerprints = baselineFingerprints(project, outputs, pieces, content, stages);
         const revision = {

package/dist/slices/revisions/downloads.js

@@ -3,6 +3,7 @@ import { extname } from "node:path";
 import { zipSync } from "fflate";
 import { z } from "zod";
 import { stageKinds } from "../../kernel/pipeline.js";
+import { thumbnailCountOf } from "../admission/model.js";
 import { contentTypeOf, downloadName, slugOf } from "../storage/downloads.js";
 import { outputPath } from "../storage/layout.js";
 import { projectTitle } from "../storage/repo.js";
@@ -47,7 +48,12 @@ export function revisionImagesZip(deps, projectId, revisionId) {
     const slug = slugOf(revision.config.title);
     const entries = {};
     const images = outputsForRevision(deps.db, projectId, revisionId)
-        .filter((row) => row.selected && (row.output.role === "image" || row.output.role === "thumbnail"))
+        .filter((row) => row.selected &&
+        (row.output.role === "image" ||
+            // Every thumbnail the project makes; a second or third left from when it made three
+            // stays out once it makes one.
+            (row.output.role === "thumbnail" &&
+                (row.output.meta.index ?? 1) <= thumbnailCountOf(revision.config))))
         .map((row) => positionedOutput(revision, row))
         .sort((a, b) => imageOrder(a.output.role, a.output.meta.index) -
         imageOrder(b.output.role, b.output.meta.index));

package/dist/slices/revisions/image-plan.js

@@ -0,0 +1,183 @@
+// Image prompts and their Numbers changed in Edit project. A project's images were planned per
+// prompt when its run was adopted (`adopt-content.ts`): each image is a definition under
+// `imagePrompts.N`, Number times per prompt. Changing which prompts are used, or a Number,
+// re-derives those definitions here, the way Play's plan lays them out (prompts in selection
+// order, Number images each), while keeping every definition a prompt already has: an image
+// keeps its key and its wording, so its fingerprint - and the image made for it - stays.
+//
+// The edit's content is read in the numbering of `from` (the prompts the revision was saved
+// with); the result is in the numbering of `to`. The browser calls this too, with stand-in
+// keys, to say what saving will add and remove.
+import { imagesPerRunMax, numberPerPromptMax } from "../admission/rules.js";
+import { render } from "../admission/substitute.js";
+export function imagePromptKey(index) {
+    return `imagePrompts.${String(index)}`;
+}
+function promptIndex(key) {
+    const match = /^imagePrompts\.(\d+)$/.exec(key ?? "");
+    return match?.[1] === undefined ? undefined : Number(match[1]);
+}
+export function sameImagePrompts(from, to) {
+    return (from.length === to.length &&
+        from.every((one, index) => one.name === to[index]?.name && one.number === to[index]?.number));
+}
+// The same bounds Play's admission holds a run to.
+export function imagePromptFields(to) {
+    const fields = [];
+    if (to.length === 0)
+        fields.push({
+            field: "imagePrompts",
+            message: "Tick at least one image prompt under Images, or set Images to Off or Provide on Inputs.",
+        });
+    const names = new Set();
+    for (const [index, prompt] of to.entries()) {
+        if (prompt.name.trim() === "")
+            fields.push({
+                field: `imagePrompts.${String(index)}.name`,
+                message: "Pick an image prompt.",
+            });
+        else if (names.has(prompt.name))
+            fields.push({
+                field: `imagePrompts.${String(index)}.name`,
+                message: `The image prompt "${prompt.name}" is ticked twice. Untick one under Images.`,
+            });
+        names.add(prompt.name);
+        if (!Number.isInteger(prompt.number) || prompt.number < 1 || prompt.number > numberPerPromptMax)
+            fields.push({
+                field: `imagePrompts.${String(index)}.number`,
+                message: `Enter a whole number between 1 and ${String(numberPerPromptMax)} for "${prompt.name}" under Images.`,
+            });
+    }
+    const total = to.reduce((sum, prompt) => sum + prompt.number, 0);
+    if (total > imagesPerRunMax)
+        fields.push({
+            field: "imagePrompts",
+            message: `A video can have at most ${String(imagesPerRunMax)} images; these prompts ask for ${String(total)}. Lower the Numbers under Images.`,
+        });
+    return fields;
+}
+export function replanImagePrompts(input) {
+    const { from, to, content } = input;
+    // Where each prompt of `to` was in `from`, by name: a prompt is the same prompt while its
+    // name is, wherever it now sits.
+    const was = to.map((prompt) => from.findIndex((one) => one.name === prompt.name));
+    const fields = [];
+    const templates = {};
+    const rendered = {};
+    for (const [key, value] of Object.entries(content.promptTemplates))
+        if (promptIndex(key) === undefined)
+            templates[key] = value;
+    for (const [key, value] of Object.entries(input.rendered))
+        if (promptIndex(key) === undefined)
+            rendered[key] = value;
+    for (const [index, prompt] of to.entries()) {
+        const key = imagePromptKey(index);
+        const old = was[index] ?? -1;
+        if (old >= 0) {
+            const oldKey = imagePromptKey(old);
+            if (Object.hasOwn(content.promptTemplates, oldKey))
+                templates[key] = content.promptTemplates[oldKey] ?? null;
+            const text = input.rendered[oldKey];
+            if (text !== undefined)
+                rendered[key] = text;
+            continue;
+        }
+        const body = input.body(prompt.name);
+        if (body === undefined) {
+            fields.push({
+                field: `imagePrompts.${String(index)}.name`,
+                message: `The image prompt "${prompt.name}" is not in the Library any more. Untick it under Images, or add it back on Library → Prompts.`,
+            });
+            continue;
+        }
+        templates[key] = body;
+        rendered[key] = render(body, input.values);
+    }
+    if (fields.length > 0)
+        return { ok: false, fields };
+    // The definitions each prompt of `from` has now, in slideshow order.
+    const groups = new Map();
+    for (const key of content.imageOrder) {
+        const index = promptIndex(content.imageDefinitions[key]?.templateKey);
+        if (index === undefined || index >= from.length)
+            continue;
+        groups.set(index, [...(groups.get(index) ?? []), key]);
+    }
+    const definitions = {};
+    const added = [];
+    const removed = [];
+    // New images for a prompt: its first image's wording when it has one, else the prompt's own.
+    const fresh = (index, like) => {
+        const key = imagePromptKey(index);
+        const template = templates[key];
+        return like === undefined
+            ? {
+                source: "generate",
+                assetId: null,
+                prompt: rendered[key] ?? null,
+                templateKey: template === undefined || template === null ? null : key,
+            }
+            : { ...like, source: "generate", assetId: null, templateKey: like.templateKey ?? null };
+    };
+    const extra = (index, count, like) => Array.from({ length: Math.max(0, count) }, () => {
+        const id = input.key();
+        definitions[id] = fresh(index, like);
+        added.push(id);
+        return id;
+    });
+    const order = [];
+    for (const key of content.imageOrder) {
+        const definition = content.imageDefinitions[key];
+        if (definition === undefined)
+            continue;
+        const old = promptIndex(definition.templateKey);
+        if (old === undefined || old >= from.length) {
+            // An image added on its own, or uploaded: not any prompt's, so it stays where it is.
+            definitions[key] = definition;
+            order.push(key);
+            continue;
+        }
+        const index = was.indexOf(old);
+        if (index === -1) {
+            removed.push(key);
+            continue;
+        }
+        const group = groups.get(old) ?? [];
+        const changed = from[old]?.number !== to[index]?.number;
+        const keep = changed ? (to[index]?.number ?? 0) : group.length;
+        const at = group.indexOf(key);
+        if (at >= keep) {
+            removed.push(key);
+            continue;
+        }
+        const moved = definition.templateKey === imagePromptKey(index)
+            ? definition
+            : { ...definition, templateKey: imagePromptKey(index) };
+        definitions[key] = moved;
+        order.push(key);
+        // A raised Number adds its images right after the prompt's last one.
+        if (changed && at === Math.min(group.length, keep) - 1)
+            order.push(...extra(index, keep - group.length, moved));
+    }
+    for (const [index, prompt] of to.entries()) {
+        const old = was[index] ?? -1;
+        const group = old >= 0 ? (groups.get(old) ?? []) : [];
+        // A prompt with no image left (every one removed by hand) makes its Number again only when
+        // the Number changed; a prompt new to the project makes all of them, at the end.
+        if (old >= 0 && (group.length > 0 || from[old]?.number === prompt.number))
+            continue;
+        order.push(...extra(index, prompt.number, undefined));
+    }
+    return {
+        ok: true,
+        content: {
+            ...content,
+            imageOrder: order,
+            imageDefinitions: definitions,
+            promptTemplates: templates,
+        },
+        rendered,
+        added,
+        removed,
+    };
+}

package/dist/slices/revisions/mutation-assets.js

@@ -144,6 +144,16 @@ export function validateAssetReferences(deps, projectId, content, prepared) {
             field: "content.shortsMusic",
             message: "This music file does not belong to this project. Reload the page and choose the music again.",
         });
+    // The ambient bed's own file is only ever the one the project was started with.
+    const bed = content.ambientBed;
+    if (bed !== undefined &&
+        deps.db
+            .prepare("SELECT 1 FROM project_revisions WHERE project_id=? AND json_extract(content,'$.ambientBed')=? LIMIT 1")
+            .get(projectId, bed) === undefined)
+        fields.push({
+            field: "content.ambientBed",
+            message: "This ambient sound file does not belong to this project. Reload the page and save again.",
+        });
     return fields;
 }
 export async function measureAudio(deps, projectId, path) {

package/dist/slices/revisions/mutation-cues.js

@@ -1,6 +1,59 @@
+import { readFileSync } from "node:fs";
 import { isDeepStrictEqual } from "node:util";
+import { z } from "zod";
+import { outputPath } from "../storage/layout.js";
+import { usesVoices } from "../voices/model.js";
+import { cueSpeaker } from "../voices/timing.js";
 import { assetPath, measureAudio } from "./mutation-assets.js";
 import { validateCues } from "./rules.js";
+// Edited captions of a multi-voice run keep their speakers. A cue that comes back without one
+// (the caption editor edits text and times only) takes the speaker it had before, found by the
+// cue's id, and a new cue the speaker of the narration under it, from the word timing. A cue
+// sent with a speaker keeps it. Runs with one voice are left as they are.
+export function withCueSpeakers(deps, base, edit) {
+    const edited = edit.content.subtitleCues;
+    if (edited === undefined ||
+        !usesVoices(edit.config) ||
+        !cuesChanged(base, edit) ||
+        edited.cues.every((cue) => cue.speaker !== undefined))
+        return edit;
+    const before = new Map((base.revision.content.subtitleCues?.cues ?? []).flatMap((cue) => cue.speaker === undefined ? [] : [[cue.id, cue.speaker]]));
+    let words;
+    const timing = () => {
+        if (words !== undefined)
+            return words;
+        const row = base.outputs.find((one) => one.selected &&
+            one.available &&
+            one.state === "ready" &&
+            one.workKey === "subtitles:timing" &&
+            one.output.role === "subtitle_words");
+        try {
+            words =
+                row === undefined
+                    ? []
+                    : timedWords.parse(JSON.parse(readFileSync(outputPath(deps.paths, base.revision.projectId, row.output.path), "utf8"))).words;
+        }
+        catch {
+            // Unreadable timing leaves the new cues without a speaker; they still save.
+            words = [];
+        }
+        return words;
+    };
+    const cues = edited.cues.map((cue) => {
+        if (cue.speaker !== undefined)
+            return cue;
+        const speaker = before.get(cue.id) ?? cueSpeaker(cue, timing() ?? []);
+        return speaker === undefined ? cue : { ...cue, speaker };
+    });
+    return { ...edit, content: { ...edit.content, subtitleCues: { ...edited, cues } } };
+}
+const timedWords = z.object({
+    words: z.array(z.object({
+        start: z.number(),
+        end: z.number(),
+        speaker: z.string().optional(),
+    })),
+});
 export function cuesChanged(base, edit) {
     return (edit.content.subtitleCues !== undefined &&
         !isDeepStrictEqual(base.revision.content.subtitleCues, edit.content.subtitleCues));
@@ -54,12 +107,30 @@ export function validateProposedCues(base, edit, plan, prepared, durations) {
             return undefined;
         if (recipe.input.kind === "provided" && recipe.input.assetId !== null)
             return durations.get(recipe.input.assetId);
+        // Pauses between sentences lengthen the join by what only the join measures.
+        if (recipe.input.kind === "local" &&
+            Array.isArray(recipe.input.values) &&
+            recipe.input.values[2] !== undefined)
+            return undefined;
         if (recipe.input.kind === "local" && recipe.input.operation === "concat-narration") {
             const parts = recipe.dependsOn.map(durationFor);
             return parts.some((one) => one === undefined)
                 ? undefined
                 : parts.reduce((sum, one) => sum + (one ?? 0), 0);
         }
+        // Speaker turns: each at its pace, with the gap after it (`recipe-voices.ts`).
+        if (recipe.input.kind === "local" && recipe.input.operation === "concat-turns-v1") {
+            const layout = Array.isArray(recipe.input.values) ? recipe.input.values[1] : undefined;
+            const parts = recipe.dependsOn.map(durationFor);
+            if (!Array.isArray(layout) || parts.some((one) => one === undefined))
+                return undefined;
+            return parts.reduce((sum, one, index) => {
+                const [pace, gap] = Array.isArray(layout[index]) ? layout[index] : [1, 0];
+                return (sum +
+                    (one ?? 0) / (typeof pace === "number" && pace > 0 ? pace : 1) +
+                    (typeof gap === "number" ? gap * 1000 : 0));
+            }, 0);
+        }
         if (plan.baseFingerprints[key] !== plan.fingerprints[key])
             return undefined;
         const prefix = key.replace(/:1$/, ":");

package/dist/slices/revisions/mutation-request.js

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import { z } from "zod";
+import { projectExists } from "../admission/repo.js";
 import { currentRevisionId } from "./repo.js";
 import { getRevisionView } from "./view.js";
 export function requestHash(operation, baseRevisionId, input) {
@@ -43,7 +44,7 @@ export function checkMutation(deps, input) {
         .prepare("SELECT 1 FROM project_recovery_requests WHERE project_id=? AND idempotency_key=?")
         .get(input.projectId, input.idempotencyKey) !== undefined)
         return refusal(deps, input.projectId, "idempotency-conflict");
-    if (db.prepare("SELECT 1 FROM projects WHERE id=?").get(input.projectId) === undefined)
+    if (!projectExists(db, input.projectId))
         return refusal(deps, input.projectId, "no-project");
     if (currentRevisionId(db, input.projectId) !== input.baseRevisionId)
         return refusal(deps, input.projectId, "conflict");

package/dist/slices/revisions/mutations.js

@@ -1,6 +1,10 @@
 import { z } from "zod";
 import { transact } from "../../kernel/db/tx.js";
+import { rebrandedEdit } from "../channels/rebrand.js";
+import { projectChannelId, resolveChannelId, setProjectChannel } from "../channels/repo.js";
 import { carryCheckpointGates } from "../checkpoints/recovery.js";
+import { imageCountsOf, imageScaleProblem } from "../images/scale.js";
+import { promptByName } from "../library/repo.js";
 import { narrationRegenerationKey } from "../narration/plan.js";
 import { recipeInputSchema } from "../rebuild/recipe-input-schema.js";
 import { planRevision } from "../rebuild/recipe-save.js";
@@ -9,8 +13,10 @@ import { projectStandings } from "../rebuild/runtime-store.js";
 import { discardPreparedAssets } from "../storage/assets.js";
 import { deleteStagedFile } from "../storage/repo.js";
 import { releaseStagedFile } from "../storage/staging-refs.js";
+import { ambientBedProblems } from "../video/ambient-bed.js";
+import { imagePromptFields, replanImagePrompts, sameImagePrompts } from "./image-plan.js";
 import { validateAssetReferences, validateReplacementAvailability, validateUploads, } from "./mutation-assets.js";
-import { cuesChanged, inspectCueAudio, measuredOutputs, validateProposedCues, } from "./mutation-cues.js";
+import { cuesChanged, inspectCueAudio, measuredOutputs, validateProposedCues, withCueSpeakers, } from "./mutation-cues.js";
 import { prepareEditAssets } from "./mutation-prepare.js";
 import { checkMutation, insertReceipt, requestHash, requiredView } from "./mutation-request.js";
 import { preserveDeferredIntent } from "./mutation-work.js";
@@ -43,8 +49,17 @@ export async function saveRevision(deps, input) {
     if (checked !== undefined)
         return checked;
     const base = requiredView(deps, input.projectId, input.baseRevisionId);
-    const edit = bindNarrationSources(base, submitted);
+    const replanned = replannedImages(deps, base, submitted);
+    if (!replanned.ok)
+        return {
+            ok: false,
+            reason: "invalid-edit",
+            currentRevisionId: base.revision.id,
+            fields: replanned.fields,
+        };
+    const edit = bindNarrationSources(base, rebrandedEdit(deps.db, base.revision.config, replanned.edit));
     const fields = [
+        ...settingProblems(edit),
         ...validateUploads(deps, edit),
         ...validateTemplateIntent(base, edit),
         ...validateNarrationIntent(base, edit),
@@ -60,7 +75,8 @@ export async function saveRevision(deps, input) {
             currentRevisionId: base.revision.id,
             fields: unavailable,
         };
-    const { edit: supplied, assets: prepared } = await prepareEditAssets(deps, base, edit);
+    const { edit: uploaded, assets: prepared } = await prepareEditAssets(deps, base, edit);
+    const supplied = withCueSpeakers(deps, base, uploaded);
     try {
         const durations = await inspectCueAudio(deps, base, supplied, prepared);
         const result = transact(deps.db, () => {
@@ -173,12 +189,90 @@ export async function saveRevision(deps, input) {
             .filter((asset) => deps.db.prepare("SELECT 1 FROM project_assets WHERE id=?").get(asset.id) === undefined));
     }
 }
+// Settings Edit project changes that admission checks at Play's Start: the ambient bed's
+// numbers and More images for long videos. Said where Edit project shows them.
+function settingProblems(edit) {
+    const bed = edit.config.ambientBed;
+    const scale = edit.config.imageScale;
+    const scaleProblem = scale === undefined ? undefined : imageScaleProblem(scale);
+    return [
+        ...(bed === undefined
+            ? []
+            : ambientBedProblems(bed).map((problem) => ({
+                field: `ambientBed.${problem.field}`,
+                message: `${problem.message} Change it in Edit project → Inputs → Ambient sound.`,
+            }))),
+        ...(scaleProblem === undefined
+            ? []
+            : [
+                {
+                    field: "imageScale",
+                    message: `${scaleProblem} Change it in Edit project → Images → More images for long videos.`,
+                },
+            ]),
+    ];
+}
+// The image prompts or their Numbers changed: the image definitions are planned again from
+// them (`image-plan.ts`), keeping every image an unchanged prompt already has.
+function replannedImages(deps, base, edit) {
+    // Planned in the counts each prompt actually makes: its Number, plus its share of the extra
+    // images More images for long videos adds (`images/scale.ts`), as the run was adopted.
+    const effective = (config) => {
+        const counts = imageCountsOf(config);
+        return config.imagePrompts.map((prompt, index) => ({
+            ...prompt,
+            number: counts[index] ?? prompt.number,
+        }));
+    };
+    if (edit.config.sources.images !== "generate" &&
+        sameImagePrompts(base.revision.config.imagePrompts, edit.config.imagePrompts))
+        return { ok: true, edit };
+    const from = effective(base.revision.config);
+    const to = effective(edit.config);
+    if (sameImagePrompts(from, to))
+        return { ok: true, edit };
+    if (edit.config.sources.images !== "generate")
+        return {
+            ok: false,
+            fields: [
+                {
+                    field: "imagePrompts",
+                    message: "Image prompts are used only while Images is set to Generate. Set Images to Generate on Inputs, or leave the prompts as they were.",
+                },
+            ],
+        };
+    const fields = imagePromptFields(edit.config.imagePrompts);
+    if (fields.length > 0)
+        return { ok: false, fields };
+    const plan = replanImagePrompts({
+        from,
+        to,
+        content: edit.content,
+        rendered: edit.config.rendered,
+        values: edit.config.values,
+        body: (name) => promptByName(deps.db, "image", name)?.body,
+        key: () => deps.ids.next(),
+    });
+    if (!plan.ok)
+        return plan;
+    return {
+        ok: true,
+        edit: { ...edit, config: { ...edit.config, rendered: plan.rendered }, content: plan.content },
+    };
+}
 export function advanceHead(db, projectId, baseRevisionId, revision) {
     const result = db
         .prepare("UPDATE project_heads SET revision_id = ? WHERE project_id = ? AND revision_id = ?")
         .run(revision.id, projectId, baseRevisionId);
     if (Number(result.changes) !== 1)
         return false;
+    // The project's channel follows its settings: moved in Edit project, or restored to a
+    // version from another channel. A channel since deleted leaves the project where it is.
+    const channelId = revision.config.channelId;
+    if (channelId !== undefined &&
+        resolveChannelId(db, channelId) === channelId &&
+        projectChannelId(db, projectId) !== channelId)
+        setProjectChannel(db, projectId, channelId);
     db.prepare("UPDATE projects SET title = ?, format = ?, config = ?, updated_at = ? WHERE id = ?").run(revision.config.title, revision.config.format, JSON.stringify(revision.config), revision.createdAt, projectId);
     return true;
 }

package/dist/slices/revisions/schema.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { stageKinds } from "../../kernel/pipeline.js";
 import { pieceKinds, pieceStates } from "../../kernel/runner/piece-repo.js";
 import { runConfigSchema } from "../admission/schema.js";
+import { scaledImagesMax } from "../images/scale.js";
 import { outputSchema } from "../storage/schema.js";
 const id = z
     .string()
@@ -16,6 +17,13 @@ const cue = z
     text: z.string().trim().min(1).max(10000),
     start: z.number().finite().nonnegative(),
     end: z.number().finite().positive(),
+    // The speaker's id on a multi-voice run (`voices/model.ts`); absent everywhere else.
+    speaker: z
+        .string()
+        .min(1)
+        .max(60)
+        .regex(/^[a-z0-9-]+$/)
+        .optional(),
 })
     .strict()
     .refine((value) => value.end > value.start, {
@@ -35,7 +43,8 @@ export const revisionContentSchema = z
         reference: id.optional(),
     })
         .strict(),
-    imageOrder: z.array(id).max(60),
+    // The most any project may hold; `rebuild/recipe-validation.ts` holds each to its own cap.
+    imageOrder: z.array(id).max(scaledImagesMax),
     imageDefinitions: z.record(id, z
         .object({
         source: z.enum(["generate", "provide"]),
@@ -79,6 +88,7 @@ export const revisionContentSchema = z
     })
         .strict())
         .optional(),
+    ambientBed: id.optional(),
 })
     .strict();
 export const revisionEditSchema = z

package/dist/slices/run-cost/limits.js

@@ -0,0 +1,128 @@
+import { z } from "zod";
+import { causedBy } from "../../kernel/errors.js";
+// Living within a CLI's plan limits. When a CLI says its allowance is used up, the time it
+// returns is stored per account; every call to that CLI - from any project, and after a
+// restart - waits for it instead of failing. Other providers are untouched, so a project
+// whose narration is keyed carries on while its Codex images wait.
+// Waking a little after the stated reset, so the first call is not refused again at the edge.
+export const resetMarginMs = 2 * 60_000;
+// When the CLI names no reset time, the wait checks again this often.
+export const recheckMs = 30 * 60_000;
+const waitRow = z.object({ retry_at: z.string() });
+export function createLimitGate(deps) {
+    // How many calls of one stage wait on one account: a stage drawing four Codex images at
+    // once shows one wait, removed when the last of them wakes.
+    const waiting = new Map();
+    const retryAt = (account) => {
+        const row = deps.db
+            .prepare("SELECT retry_at FROM plan_limit_waits WHERE account = ?")
+            .get(account);
+        if (row === undefined)
+            return undefined;
+        return Date.parse(waitRow.parse(row).retry_at);
+    };
+    const begin = (account, waiter) => {
+        const key = JSON.stringify([waiter.projectId, waiter.stage, account]);
+        waiting.set(key, (waiting.get(key) ?? 0) + 1);
+        const inserted = deps.db
+            .prepare("INSERT OR IGNORE INTO plan_limit_waiters (project_id, stage, account, since) VALUES (?, ?, ?, ?)")
+            .run(waiter.projectId, waiter.stage, account, deps.clock.now().toISOString());
+        if (inserted.changes === 1)
+            deps.changed(waiter.projectId);
+    };
+    // Only a wait that ran its course removes the row. One cut short by cancel, pause or the
+    // app stopping leaves it, and the next start decides what it means (resumeAfterRestart).
+    const end = (account, waiter, woke) => {
+        const key = JSON.stringify([waiter.projectId, waiter.stage, account]);
+        const left = (waiting.get(key) ?? 1) - 1;
+        if (left > 0) {
+            waiting.set(key, left);
+            return;
+        }
+        waiting.delete(key);
+        if (!woke)
+            return;
+        deps.db
+            .prepare("DELETE FROM plan_limit_waiters WHERE project_id = ? AND stage = ? AND account = ?")
+            .run(waiter.projectId, waiter.stage, account);
+        deps.changed(waiter.projectId);
+    };
+    return {
+        ready: async (account, waiter, signal) => {
+            for (;;) {
+                signal.throwIfAborted();
+                const due = retryAt(account);
+                if (due === undefined)
+                    return;
+                const left = due - deps.clock.now().getTime();
+                if (left <= 0) {
+                    // Past the reset: the allowance is back. A call refused again stores a new wait.
+                    deps.db
+                        .prepare("DELETE FROM plan_limit_waits WHERE account = ? AND retry_at <= ?")
+                        .run(account, deps.clock.now().toISOString());
+                    return;
+                }
+                begin(account, waiter);
+                let woke = false;
+                try {
+                    await deps.clock.sleep(left, signal);
+                    woke = true;
+                }
+                finally {
+                    end(account, waiter, woke);
+                }
+            }
+        },
+        exhausted: (hit) => {
+            const now = deps.clock.now().getTime();
+            const reset = hit.resetsAt === null ? Number.NaN : Date.parse(hit.resetsAt);
+            // A stated reset already past (a clock skew, a stale message) is checked again soon.
+            const due = Number.isFinite(reset) && reset > now ? reset + resetMarginMs : now + recheckMs;
+            const retry = new Date(due).toISOString();
+            try {
+                deps.db
+                    .prepare(`INSERT INTO plan_limit_waits (account, resets_at, retry_at, detected_at) VALUES (?, ?, ?, ?)
+             ON CONFLICT(account) DO UPDATE SET resets_at = excluded.resets_at, retry_at = excluded.retry_at, detected_at = excluded.detected_at
+             WHERE excluded.retry_at > plan_limit_waits.retry_at`)
+                    .run(hit.account, Number.isFinite(reset) && reset > now ? new Date(reset).toISOString() : null, retry, new Date(now).toISOString());
+            }
+            catch (error) {
+                deps.log.write("error", "plan-limits", { detail: causedBy(error) });
+                throw error;
+            }
+            deps.log.write("info", "plan-limits", {
+                detail: `${hit.account} plan limit used up; waiting until ${retry}`,
+            });
+        },
+    };
+}
+// At start, a stage that was waiting on a plan limit when the app stopped was marked
+// interrupted like any other (main.ts markInterruptedStages). Those projects are resumed so
+// the wait carries on by itself - their calls meet the stored reset and wait again. A project
+// paused or cancelled meanwhile is left as it is.
+export async function resumeAfterRestart(db, resume, log) {
+    const projects = db
+        .prepare(`SELECT DISTINCT w.project_id AS id FROM plan_limit_waiters w
+       JOIN stages s ON s.project_id = w.project_id AND s.kind = w.stage
+       WHERE s.state = 'failed' AND s.failure_reason = 'interrupted'
+       AND NOT EXISTS (SELECT 1 FROM project_controls c WHERE c.project_id = w.project_id AND c.paused = 1)`)
+        .all()
+        .map((row) => z.string().parse(row.id));
+    db.prepare("DELETE FROM plan_limit_waiters").run();
+    let resumed = 0;
+    for (const projectId of projects) {
+        try {
+            if (await resume(projectId))
+                resumed += 1;
+            else
+                log.write("warn", "plan-limits", {
+                    projectId,
+                    detail: "A project waiting for CLI limits could not be resumed after the restart; use Continue the run on the project page.",
+                });
+        }
+        catch (error) {
+            log.write("error", "plan-limits", { projectId, detail: causedBy(error) });
+        }
+    }
+    return resumed;
+}