@gentbajko/slopify 0.8.3 → 1.0.0

package/dist/adapters/tts/inworld.js

@@ -3,7 +3,6 @@ import { redact } from "../../kernel/log.js";
 import { providerError } from "../../kernel/ports/model.js";
 import { retryAfter } from "../retry-after.js";
 import { inworldAsync } from "./inworld-async.js";
-import { inworldTextParts } from "./inworld-text.js";
 export const inworldModels = [
     { id: "inworld-tts-2", name: "Realtime TTS-2" },
     { id: "inworld-tts-2-flash", name: "Realtime TTS-2 Flash" },
@@ -26,7 +25,7 @@ export function inworldTts(deps) {
                 throw providerError({ kind: "missing_key", message: "No Inworld API key is stored." });
             const cancel = new AbortController();
             const signal = AbortSignal.any([request.signal, cancel.signal]);
-            const iterator = synthesizeParts(deps, { ...request, signal }, key);
+            const iterator = synthesizeRequest(deps, { ...request, signal }, key);
             return {
                 container: "mp3",
                 audio: new ReadableStream({
@@ -51,85 +50,91 @@ export function inworldTts(deps) {
         },
     };
 }
-async function* synthesizeParts(deps, request, key) {
-    if ((request.model ?? "inworld-tts-2") === "inworld-tts-2" && request.text.length > 4000) {
+async function* synthesizeRequest(deps, request, key) {
+    if (request.continuation?.read() !== undefined) {
         yield* inworldAsync(deps, request, key);
         return;
     }
-    const parts = inworldTextParts(request.text);
-    if (parts.length === 0)
+    if (request.text.trim().length === 0)
         throw providerError({ kind: "unsupported", message: "Inworld needs text to narrate." });
-    for (const text of parts) {
-        request.signal.throwIfAborted();
-        const response = await deps.fetch("https://api.inworld.ai/tts/v1/voice:stream", {
-            method: "POST",
-            redirect: "error",
-            signal: request.signal,
-            headers: { Authorization: `Basic ${key}`, "Content-Type": "application/json" },
-            body: JSON.stringify({
-                text,
-                voiceId: request.voiceId,
-                modelId: request.model ?? "inworld-tts-2",
-                audioConfig: { audioEncoding: "MP3", sampleRateHertz: 48_000, bitRate: 128_000 },
-            }),
+    if ((request.model ?? "inworld-tts-2") === "inworld-tts-2" && request.text.length > 4000) {
+        yield* inworldAsync(deps, request, key);
+        return;
+    }
+    if (request.text.length > 4000)
+        throw providerError({
+            kind: "unsupported",
+            message: "Inworld streaming accepts up to 4,000 characters per physical request. Rebuild narration with a supported request limit.",
         });
-        if (!response.ok) {
-            const detail = clean(await response.text().catch(() => ""), key);
-            const retryAfterMs = retryAfter(response.headers.get("retry-after"));
+    request.signal.throwIfAborted();
+    const response = await deps.fetch("https://api.inworld.ai/tts/v1/voice:stream", {
+        method: "POST",
+        redirect: "error",
+        signal: request.signal,
+        headers: { Authorization: `Basic ${key}`, "Content-Type": "application/json" },
+        body: JSON.stringify({
+            text: request.text,
+            voiceId: request.voiceId,
+            modelId: request.model ?? "inworld-tts-2",
+            audioConfig: { audioEncoding: "MP3", sampleRateHertz: 48_000, bitRate: 128_000 },
+        }),
+    });
+    if (!response.ok) {
+        const detail = clean(await response.text().catch(() => ""), key);
+        const retryAfterMs = retryAfter(response.headers.get("retry-after"));
+        throw providerError({
+            kind: response.status === 401 || response.status === 403
+                ? "auth"
+                : response.status === 429
+                    ? "rate_limit"
+                    : response.status === 400 || response.status === 404
+                        ? "unsupported"
+                        : "other",
+            message: clean(`Inworld answered ${response.status} for voice ${request.voiceId}: ${detail || response.statusText}`, key),
+            ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
+        });
+    }
+    if (response.body === null)
+        throw invalid("answered with no audio");
+    let heard = false;
+    for await (const line of lines(response.body)) {
+        request.signal.throwIfAborted();
+        let raw;
+        try {
+            raw = JSON.parse(line);
+        }
+        catch {
+            throw invalid("sent an unreadable audio chunk");
+        }
+        const parsed = envelope.safeParse(raw);
+        if (!parsed.success || (!parsed.data.result && !parsed.data.error))
+            throw invalid("sent an unreadable audio chunk");
+        if (parsed.data.error) {
+            const { code, message } = parsed.data.error;
             throw providerError({
-                kind: response.status === 401 || response.status === 403
+                kind: code === 16 || code === 7
                     ? "auth"
-                    : response.status === 429
+                    : code === 8
                         ? "rate_limit"
-                        : response.status === 400 || response.status === 404
+                        : code === 3 || code === 5
                             ? "unsupported"
                             : "other",
-                message: clean(`Inworld answered ${response.status} for voice ${request.voiceId}: ${detail || response.statusText}`, key),
-                ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
+                message: `Inworld stream failed: ${clean(message ?? "audio generation stopped", key)}`,
             });
         }
-        if (response.body === null)
-            throw invalid("answered with no audio");
-        let heard = false;
-        for await (const line of lines(response.body)) {
-            request.signal.throwIfAborted();
-            let raw;
-            try {
-                raw = JSON.parse(line);
-            }
-            catch {
-                throw invalid("sent an unreadable audio chunk");
-            }
-            const parsed = envelope.safeParse(raw);
-            if (!parsed.success || (!parsed.data.result && !parsed.data.error))
-                throw invalid("sent an unreadable audio chunk");
-            if (parsed.data.error) {
-                const { code, message } = parsed.data.error;
-                throw providerError({
-                    kind: code === 16 || code === 7
-                        ? "auth"
-                        : code === 8
-                            ? "rate_limit"
-                            : code === 3 || code === 5
-                                ? "unsupported"
-                                : "other",
-                    message: `Inworld stream failed: ${clean(message ?? "audio generation stopped", key)}`,
-                });
-            }
-            const encoded = parsed.data.result?.audioContent;
-            if (!encoded)
-                continue;
-            if (!/^[A-Za-z0-9+/]*={0,2}$/.test(encoded) || encoded.length % 4 === 1)
-                throw invalid("sent invalid encoded audio");
-            const audio = Buffer.from(encoded, "base64");
-            if (audio.length === 0)
-                continue;
-            heard = true;
-            yield audio;
-        }
-        if (!heard)
-            throw invalid("answered with no audio");
+        const encoded = parsed.data.result?.audioContent;
+        if (!encoded)
+            continue;
+        if (!/^[A-Za-z0-9+/]*={0,2}$/.test(encoded) || encoded.length % 4 === 1)
+            throw invalid("sent invalid encoded audio");
+        const audio = Buffer.from(encoded, "base64");
+        if (audio.length === 0)
+            continue;
+        heard = true;
+        yield audio;
     }
+    if (!heard)
+        throw invalid("answered with no audio");
 }
 async function* lines(body) {
     const reader = body.getReader();

package/dist/catalog/registry.js

@@ -1,5 +1,4 @@
 import { providerError } from "../kernel/ports/model.js";
-import { splitText } from "../kernel/ports/text.js";
 export function curateRegistry(registry, catalogue) {
     const requireModel = (provider, family, id) => {
         const models = catalogue.models(provider, family);
@@ -40,7 +39,10 @@ export function curateRegistry(registry, catalogue) {
                             kind: "unsupported",
                             message: "This model does not support the selected thinking setting. Choose an available setting.",
                         });
-                    yield* port.complete({ ...request, ...(thinkingConfig ? { thinkingConfig } : {}) });
+                    yield* port.complete({
+                        ...request,
+                        ...(request.thinkingConfig === undefined && thinkingConfig ? { thinkingConfig } : {}),
+                    });
                 },
             };
         },
@@ -66,82 +68,20 @@ export function curateRegistry(registry, catalogue) {
                 ...port,
                 models: async () => catalogue.models(id, "tts"),
                 synthesize: async (request) => {
+                    // Retrieval resumes an already accepted job even if new submissions are disabled.
+                    if (request.continuation?.read() !== undefined)
+                        return port.synthesize(request);
                     const model = requireModel(id, "tts", request.model);
                     if (!("tts" in model))
                         throw new Error("Invalid TTS catalogue entry");
-                    const parts = splitText(request.text, model.tts.maxCharacters);
-                    if (parts.length <= 1)
-                        return port.synthesize({ ...request, model: model.id });
-                    const abort = new AbortController();
-                    const signal = AbortSignal.any([request.signal, abort.signal]);
-                    const iterator = audioParts(parts, { ...request, model: model.id, signal }, port.synthesize);
-                    return {
-                        container: "mp3",
-                        audio: new ReadableStream({
-                            async pull(controller) {
-                                try {
-                                    const next = await iterator.next();
-                                    if (next.done)
-                                        controller.close();
-                                    else
-                                        controller.enqueue(next.value);
-                                }
-                                catch (error) {
-                                    controller.error(error);
-                                }
-                            },
-                            async cancel() {
-                                abort.abort();
-                                await iterator.return();
-                            },
-                        }, { highWaterMark: 0 }),
-                    };
+                    if (request.text.length > model.tts.maxCharacters)
+                        throw providerError({
+                            kind: "unsupported",
+                            message: `${id}: this physical narration request exceeds the current ${model.tts.maxCharacters}-character limit. Rebuild narration to split it using the new limit.`,
+                        });
+                    return port.synthesize({ ...request, model: model.id });
                 },
             };
         },
     };
 }
-async function* audioParts(parts, request, synthesize) {
-    let tokens = {};
-    const saved = request.continuation?.read();
-    if (saved) {
-        try {
-            const parsed = JSON.parse(saved);
-            if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
-                tokens = Object.fromEntries(Object.entries(parsed).filter((entry) => typeof entry[1] === "string"));
-        }
-        catch {
-            /* A legacy single-job token cannot identify several split jobs. */
-        }
-    }
-    for (const [index, text] of parts.entries()) {
-        request.signal.throwIfAborted();
-        // Body chunks are persisted individually by narration. Long intro/outro text
-        // is bounded here as well; each split has its own remote continuation.
-        const response = await synthesize({
-            ...request,
-            text,
-            continuation: {
-                read: () => tokens[String(index)],
-                write: (value) => {
-                    tokens[String(index)] = value;
-                    request.continuation?.write(JSON.stringify(tokens));
-                },
-            },
-        });
-        const reader = response.audio.getReader();
-        try {
-            for (;;) {
-                const next = await reader.read();
-                request.signal.throwIfAborted();
-                if (next.done)
-                    break;
-                yield next.value;
-            }
-        }
-        finally {
-            await reader.cancel().catch(() => { });
-            reader.releaseLock();
-        }
-    }
-}

package/dist/edge/cli.js

@@ -5,6 +5,7 @@ import { readVersion } from "../kernel/version.js";
 import { boot } from "../main.js";
 import { forwardManagedUpdate } from "../updater/forward.js";
 import { openBrowser } from "./open-browser.js";
+import { installSignalShutdown } from "./signal-shutdown.js";
 const { values } = parseArgs({
     options: {
         port: { type: "string" },
@@ -31,8 +32,10 @@ try {
             console.warn(message);
         });
     }
-    process.on("SIGINT", () => {
-        stop().then(() => process.exit(0), () => process.exit(1));
+    installSignalShutdown({
+        on: (signal, listener) => process.on(signal, listener),
+        stop,
+        exit: (code) => process.exit(code),
     });
 }
 catch (error) {

package/dist/edge/events/hub.js

@@ -52,7 +52,8 @@ export function createHub(deps) {
             });
             if (set.has(subscriber))
                 for (const event of previews.snapshot(projectId))
-                    send(subscriber, event);
+                    if (deps.acceptEvent?.(event) !== false)
+                        send(subscriber, event);
             return subscriber.done;
         },
         subscribeGlobal: (stream, signal) => {
@@ -63,7 +64,11 @@ export function createHub(deps) {
             return subscriber.done;
         },
         emit: (projectId, event) => {
-            previews.observe(event);
+            const accepted = deps.acceptEvent?.(event) !== false;
+            if (accepted || event.type === "stage.state")
+                previews.observe(event);
+            if (!accepted)
+                return;
             for (const subscriber of projects.get(projectId) ?? []) {
                 send(subscriber, event);
             }

package/dist/edge/events/preview-cache.js

@@ -8,7 +8,9 @@ export function createPreviewCache() {
                 const calls = projects.get(event.projectId);
                 if (calls) {
                     for (const [id, call] of calls)
-                        if (call.stage === event.stage)
+                        if (call.stage === event.stage &&
+                            call.revisionId === event.revisionId &&
+                            call.workId === event.workId)
                             calls.delete(id);
                     if (calls.size === 0)
                         projects.delete(event.projectId);
@@ -18,10 +20,11 @@ export function createPreviewCache() {
             if (event.type !== "llm.preview")
                 return;
             const calls = projects.get(event.projectId) ?? new Map();
-            const prior = calls.get(event.callId);
+            const identity = JSON.stringify([event.revisionId, event.workId, event.callId]);
+            const prior = calls.get(identity);
             const text = (event.reset ? event.text : `${prior?.text ?? ""}${event.text}`).slice(-64 * 1024);
-            calls.delete(event.callId);
-            calls.set(event.callId, { ...event, text, reset: true });
+            calls.delete(identity);
+            calls.set(identity, { ...event, text, reset: true });
             while (calls.size > 8) {
                 const id = calls.keys().next().value;
                 if (id !== undefined)

package/dist/edge/events/visibility.js

@@ -0,0 +1,33 @@
+import { currentRevisionId } from "../../slices/revisions/repo.js";
+export function currentWorkOrigin(db, projectId, origin) {
+    if (currentRevisionId(db, projectId) === undefined)
+        return origin.revisionId === undefined && origin.workId === undefined;
+    if (origin.revisionId === undefined || origin.workId === undefined)
+        return false;
+    return (db
+        .prepare(`
+    SELECT 1 FROM revision_work w
+    JOIN revision_work_reservations r ON r.work_id=w.id AND r.project_id=w.project_id
+    JOIN project_heads h ON h.project_id=r.project_id AND h.revision_id=r.revision_id
+    JOIN project_revisions v ON v.id=r.revision_id
+    JOIN json_each(v.fingerprints) f ON f.key=COALESCE(r.logical_key,r.work_key)
+      AND f.value=COALESCE(r.desired_fingerprint,r.fingerprint)
+    LEFT JOIN revision_work_pieces p ON p.id=r.piece_id AND p.work_id=w.id
+    WHERE w.project_id=? AND w.revision_id=? AND w.id=?
+      AND (? IS NULL OR r.piece_id=?)
+      AND (r.piece_id IS NULL OR (p.work_key=r.work_key AND p.fingerprint=r.fingerprint))
+  `)
+        .get(projectId, origin.revisionId, origin.workId, origin.workPieceId ?? null, origin.workPieceId ?? null) !== undefined);
+}
+export function currentProjectEvent(db, event) {
+    if (event.type === "project.updated")
+        return true;
+    if (event.type === "project.state" &&
+        event.revisionId === undefined &&
+        event.workId === undefined)
+        return true;
+    const head = currentRevisionId(db, event.projectId);
+    if (head !== event.revisionId)
+        return false;
+    return currentWorkOrigin(db, event.projectId, event);
+}

package/dist/edge/http/actions.js

@@ -5,17 +5,15 @@ import { stageKinds } from "../../kernel/pipeline.js";
 import { derive } from "../../kernel/runner/graph.js";
 import { projectById, projectPaused, stagesOf } from "../../slices/admission/repo.js";
 import { cancelProject } from "../../slices/cancel/index.js";
-import { changeProviders, pauseProject, resumeProject } from "../../slices/control/index.js";
-import { withProjectControl } from "../../slices/control/lock.js";
-import { providerChangesSchema } from "../../slices/control/providers.js";
-import { deleteImage, editArticle, regenerateImage, rerunStage, retryStage, } from "../../slices/reruns/index.js";
+import { settleReleasedCheckpoints } from "../../slices/checkpoints/recovery.js";
+import { pauseProject } from "../../slices/control/index.js";
+import { revisionControlSchema, } from "../../slices/control/revision-control-schema.js";
+import { adoptBaseline } from "../../slices/revisions/adopt.js";
+import { currentRevisionId } from "../../slices/revisions/repo.js";
 import { allowsCustomModel } from "../../slices/settings/models.js";
 import { providerStatuses } from "../../slices/settings/readiness.js";
 import { outputsOf } from "../../slices/storage/repo.js";
 import { onInvalid, problem, titleOf } from "./problem.js";
-// The actions on the project header and on each stage: Cancel, Retry, Re-run, Save &
-// re-run, Regenerate one image, Delete one image. Every one changes rows and files through
-// a slice and then ticks the runner; the route itself decides nothing.
 const idParam = z.object({
     id: z
         .string()
@@ -31,35 +29,11 @@ const imageParam = idParam.extend({
         .max(64)
         .regex(/^[0-9A-Za-z_-]+$/),
 });
-// ceiling: half a megabyte of markdown, which is far past any narratable article and
-// keeps a paste from filling the process's memory. A longer one needs a streamed edit.
-const articleBody = z.object({ markdown: z.string().min(1).max(500_000) });
-const status = {
-    "no-project": 404,
-    "unknown-image": 404,
-    "empty-article": 400,
-    running: 409,
-    "not-rerunnable": 409,
-    "not-retryable": 409,
-    "no-article": 409,
-    "last-image": 409,
-};
-const details = {
-    "no-project": "No project has that id.",
-    "unknown-image": "This project has no image with that id.",
-    "empty-article": "An article cannot be saved empty.",
-    // The precondition on every re-run: no stage of the project is `running`.
-    running: "This project is still running. Cancel it or wait for it to finish.",
-    "not-rerunnable": "Only a stage that has finished, failed, or been canceled can be re-run.",
-    "not-retryable": "Only a failed or canceled stage can be retried.",
-    "no-article": "This project has no article to edit yet.",
-    // At least one image always remains.
-    "last-image": "At least one image must remain, so the last one cannot be deleted.",
-};
 // The return type is inferred so Hono keeps the route types the SPA's client is
 // generated from; see stagingRoutes.
 export function actionRoutes(deps) {
     const reruns = {
+        measureAudio: deps.measureAudio,
         db: deps.db,
         paths: deps.paths,
         ids: deps.ids,
@@ -71,11 +45,14 @@ export function actionRoutes(deps) {
         clock: deps.clock,
         log: deps.log,
         abort: (projectId) => deps.runner.abortProject(projectId),
+        hasInflight: deps.runner.hasInflight,
+        settleCheckpoints: (projectId) => settleReleasedCheckpoints(deps, projectId),
         emit: (projectId, event) => {
             deps.hub.emit(projectId, event);
         },
     };
     const control = {
+        catalogue: deps.catalogue,
         ...reruns,
         runner: deps.runner,
         emit: (projectId, event) => deps.hub.emit(projectId, event),
@@ -86,6 +63,7 @@ export function actionRoutes(deps) {
     const view = (projectId) => {
         const stages = stagesOf(deps.db, projectId);
         return {
+            revisionId: currentRevisionId(deps.db, projectId) ?? null,
             project: {
                 ...projectById(deps.db, projectId),
                 status: derive(stages, projectPaused(deps.db, projectId)),
@@ -94,21 +72,6 @@ export function actionRoutes(deps) {
             outputs: outputsOf(deps.db, projectId),
         };
     };
-    // Every re-run action ends the same way: the rows are written, then the runner is asked
-    // to look at the project. The cascade does the rest by itself.
-    const started = (c, projectId, result) => {
-        if (!result.ok) {
-            return problem(c, {
-                status: status[result.reason],
-                title: titleOf(status[result.reason]),
-                detail: details[result.reason],
-            });
-        }
-        deps.hub.emit(projectId, { type: "project.updated", projectId });
-        if (!projectPaused(deps.db, projectId))
-            deps.runner.tick(projectId);
-        return c.json({ ...view(projectId), redone: result.redone });
-    };
     const controlled = (c, id, result) => {
         if (result.ok)
             return c.json(view(id));
@@ -118,6 +81,10 @@ export function actionRoutes(deps) {
             "not-editable": 409,
             "invalid-providers": 400,
             "catalog-unavailable": 503,
+            "revision-required": 409,
+            conflict: 409,
+            "idempotency-conflict": 409,
+            "rebuild-required": 409,
         };
         const messages = {
             "no-project": "No project has that id.",
@@ -125,56 +92,84 @@ export function actionRoutes(deps) {
             "not-editable": "Providers can be changed only while a project is paused or failed.",
             "invalid-providers": "The provider choices need attention.",
             "catalog-unavailable": "The provider model catalog could not be loaded. Try again.",
+            "revision-required": "Reload the project before using this control. A current revision and request ID are required.",
+            conflict: "The project changed. Reload it before using this control.",
+            "idempotency-conflict": "This request ID has already been used for a different action.",
+            "rebuild-required": "Review the affected outputs and cost before rebuilding this revision.",
         };
         return problem(c, {
             status: codes[result.reason],
             title: titleOf(codes[result.reason]),
             detail: messages[result.reason],
-            ...(result.fields === undefined ? {} : { extensions: { fields: result.fields } }),
+            extensions: {
+                reason: result.reason,
+                currentRevisionId: currentRevisionId(deps.db, id) ?? null,
+                fields: result.fields ?? [],
+            },
         });
     };
+    const controlInput = async (c, id) => {
+        if (deps.catalogue !== undefined)
+            adoptBaseline(deps, id);
+        if (currentRevisionId(deps.db, id) === undefined)
+            return undefined;
+        let body;
+        try {
+            body = await c.req.json();
+        }
+        catch (error) {
+            if (!(error instanceof SyntaxError))
+                throw error;
+            return controlled(c, id, { ok: false, reason: "revision-required" });
+        }
+        const parsed = revisionControlSchema.safeParse(body);
+        return parsed.success
+            ? parsed.data
+            : controlled(c, id, { ok: false, reason: "revision-required" });
+    };
     return new Hono()
         .post("/:id/pause", zValidator("param", idParam, onInvalid), async (c) => {
         const { id } = c.req.valid("param");
-        return controlled(c, id, await pauseProject(control, id));
-    })
-        .post("/:id/resume", zValidator("param", idParam, onInvalid), async (c) => {
-        const { id } = c.req.valid("param");
-        return controlled(c, id, await resumeProject(control, id));
+        const input = await controlInput(c, id);
+        return input instanceof Response
+            ? input
+            : controlled(c, id, await pauseProject(control, id, input));
     })
-        .patch("/:id/providers", zValidator("param", idParam, onInvalid), zValidator("json", providerChangesSchema, onInvalid), async (c) => {
+        .post("/:id/resume", zValidator("param", idParam, onInvalid), (c) => {
         const { id } = c.req.valid("param");
-        return controlled(c, id, await changeProviders(control, id, c.req.valid("json")));
+        return controlled(c, id, {
+            ok: false,
+            reason: projectById(deps.db, id) === undefined ? "no-project" : "rebuild-required",
+        });
     })
+        .patch("/:id/providers", zValidator("param", idParam, onInvalid), revisionRequired)
         .post("/:id/cancel", zValidator("param", idParam, onInvalid), async (c) => {
         const { id } = c.req.valid("param");
-        return withProjectControl(deps.db, id, async () => {
-            const result = await cancelProject(cancel, id);
-            if (!result.ok) {
-                return problem(c, { status: 404, title: titleOf(404), detail: details["no-project"] });
-            }
-            // No tick: a canceled project sits until the user retries a stage.
-            return c.json({ ...view(id), canceled: result.canceled });
-        });
+        const input = await controlInput(c, id);
+        if (input instanceof Response)
+            return input;
+        const result = await cancelProject(cancel, id, input);
+        if (!result.ok)
+            return controlled(c, id, result);
+        return c.json({ ...view(id), canceled: result.canceled });
     })
         .post("/:id/stages/:kind/retry", zValidator("param", stageParam, onInvalid), (c) => {
-        const { id, kind } = c.req.valid("param");
-        return withProjectControl(deps.db, id, () => started(c, id, retryStage(reruns, id, kind)));
-    })
-        .post("/:id/stages/:kind/rerun", zValidator("param", stageParam, onInvalid), (c) => {
-        const { id, kind } = c.req.valid("param");
-        return withProjectControl(deps.db, id, () => started(c, id, rerunStage(reruns, id, kind)));
-    })
-        .put("/:id/article", zValidator("param", idParam, onInvalid), zValidator("json", articleBody, onInvalid), (c) => {
         const { id } = c.req.valid("param");
-        return withProjectControl(deps.db, id, () => started(c, id, editArticle(reruns, id, c.req.valid("json").markdown)));
-    })
-        .delete("/:id/images/:outputId", zValidator("param", imageParam, onInvalid), (c) => {
-        const { id, outputId } = c.req.valid("param");
-        return withProjectControl(deps.db, id, () => started(c, id, deleteImage(reruns, id, outputId)));
+        return controlled(c, id, {
+            ok: false,
+            reason: projectById(deps.db, id) === undefined ? "no-project" : "rebuild-required",
+        });
     })
-        .post("/:id/images/:outputId/regenerate", zValidator("param", imageParam, onInvalid), (c) => {
-        const { id, outputId } = c.req.valid("param");
-        return withProjectControl(deps.db, id, () => started(c, id, regenerateImage(reruns, id, outputId)));
+        .post("/:id/stages/:kind/rerun", zValidator("param", stageParam, onInvalid), revisionRequired)
+        .put("/:id/article", zValidator("param", idParam, onInvalid), revisionRequired)
+        .delete("/:id/images/:outputId", zValidator("param", imageParam, onInvalid), revisionRequired)
+        .post("/:id/images/:outputId/regenerate", zValidator("param", imageParam, onInvalid), revisionRequired);
+}
+function revisionRequired(c) {
+    return problem(c, {
+        status: 409,
+        title: titleOf(409),
+        detail: "Open Edit project to save changes, then review the affected rebuild.",
+        extensions: { reason: "revision-required" },
     });
 }