@gentbajko/slopify 0.8.4 → 1.0.0

package/dist/slices/admission/repo.js

@@ -1,61 +1,8 @@
 import { z } from "zod";
 import { stageKinds, stageStates } from "../../kernel/pipeline.js";
-import { thinkingModes } from "../../kernel/ports/llm.js";
-import { chunkModes } from "../narration/chunk.js";
-import { subtitleConfigSchema } from "../subtitles/model.js";
-import { entryModes, formats, stageSources } from "./model.js";
-const providerChoice = z.object({
-    provider: z.string(),
-    model: z.string(),
-    thinking: z.enum(thinkingModes).optional(),
-});
-const entryChoice = z.object({ name: z.string(), mode: z.enum(entryModes) });
-// The shape Play posts and the shape `projects.config` holds, in one place: the second
-// is the first plus the rendered prompt texts.
-export const runDraftSchema = z.object({
-    title: z.string(),
-    format: z.enum(formats),
-    // Spelled out rather than built from stageKinds, so the inferred type carries the six
-    // keys and this schema stays assignable to the domain type without a cast.
-    sources: z.object({
-        research: z.enum(stageSources),
-        article: z.enum(stageSources),
-        audio: z.enum(stageSources),
-        images: z.enum(stageSources),
-        thumbnail: z.enum(stageSources),
-        video: z.enum(stageSources),
-    }),
-    llm: providerChoice.optional(),
-    audio: providerChoice.extend({ voice: z.string() }).optional(),
-    images: providerChoice.optional(),
-    articlePrompt: z.string().optional(),
-    imagePrompts: z.array(z.object({ name: z.string(), number: z.number() })),
-    thumbnailPrompt: z.string().optional(),
-    intro: entryChoice.optional(),
-    outro: entryChoice.optional(),
-    values: z.record(z.string(), z.string()),
-    provided: z.object({
-        research: z.string().optional(),
-        article: z.string().optional(),
-        audio: z.string().optional(),
-        images: z.array(z.string()).optional(),
-        thumbnail: z.string().optional(),
-    }),
-    // Optional until Play carries the control; unknown keys are stripped by this schema, so
-    // a mode not listed here would never reach the audio stage.
-    chunking: z
-        .object({
-        mode: z.enum(chunkModes),
-        words: z.number().optional(),
-        characters: z.number().int().min(1).max(1000000).optional(),
-    })
-        .optional(),
-    silenceGapSeconds: z.number(),
-    subtitles: subtitleConfigSchema.optional(),
-});
-export const runConfigSchema = runDraftSchema.extend({
-    rendered: z.record(z.string(), z.string()),
-});
+import { formats, stageSources } from "./model.js";
+import { runConfigSchema } from "./schema.js";
+export { runConfigSchema, runDraftSchema } from "./schema.js";
 const projectRow = z.object({
     id: z.string(),
     title: z.string(),
@@ -182,6 +129,8 @@ export function setProjectPaused(db, projectId, paused, at) {
     db.prepare("UPDATE projects SET updated_at = ? WHERE id = ?").run(at, projectId);
 }
 export function updateProjectConfig(db, projectId, config, at) {
+    if (db.prepare("SELECT 1 FROM project_heads WHERE project_id=?").get(projectId) !== undefined)
+        throw new Error("Versioned project configuration must be saved through revisions.");
     db.prepare("UPDATE projects SET config = ?, updated_at = ? WHERE id = ?").run(JSON.stringify(config), at, projectId);
 }
 // A JSON column never reaches a caller as a string.

package/dist/slices/admission/schema.js

@@ -0,0 +1,64 @@
+import { z } from "zod";
+import { thinkingModes } from "../../kernel/ports/llm.js";
+import { checkpointStageSchema } from "../checkpoints/schema.js";
+import { chunkModes } from "../narration/chunk.js";
+import { subtitleConfigSchema } from "../subtitles/model.js";
+import { entryModes, formats, stageSources } from "./model.js";
+const providerChoice = z.object({
+    provider: z.string(),
+    model: z.string(),
+    thinking: z.enum(thinkingModes).optional(),
+});
+const entryChoice = z.object({ name: z.string(), mode: z.enum(entryModes) });
+// The shape Play posts and the shape `projects.config` holds, in one place: the second
+// is the first plus the rendered prompt texts.
+export const runDraftSchema = z.object({
+    checkpoints: z
+        .array(checkpointStageSchema)
+        .max(3)
+        .refine((stages) => new Set(stages).size === stages.length)
+        .readonly()
+        .optional(),
+    title: z.string(),
+    format: z.enum(formats),
+    // Spelled out rather than built from stageKinds, so the inferred type carries the six
+    // keys and this schema stays assignable to the domain type without a cast.
+    sources: z.object({
+        research: z.enum(stageSources),
+        article: z.enum(stageSources),
+        audio: z.enum(stageSources),
+        images: z.enum(stageSources),
+        thumbnail: z.enum(stageSources),
+        video: z.enum(stageSources),
+    }),
+    llm: providerChoice.optional(),
+    audio: providerChoice.extend({ voice: z.string() }).optional(),
+    images: providerChoice.optional(),
+    articlePrompt: z.string().optional(),
+    imagePrompts: z.array(z.object({ name: z.string(), number: z.number() })),
+    thumbnailPrompt: z.string().optional(),
+    intro: entryChoice.optional(),
+    outro: entryChoice.optional(),
+    values: z.record(z.string(), z.string()),
+    provided: z.object({
+        research: z.string().optional(),
+        article: z.string().optional(),
+        audio: z.string().optional(),
+        images: z.array(z.string()).optional(),
+        thumbnail: z.string().optional(),
+    }),
+    // Optional until Play carries the control; unknown keys are stripped by this schema, so
+    // a mode not listed here would never reach the audio stage.
+    chunking: z
+        .object({
+        mode: z.enum(chunkModes),
+        words: z.number().optional(),
+        characters: z.number().int().min(1).max(1000000).optional(),
+    })
+        .optional(),
+    silenceGapSeconds: z.number(),
+    subtitles: subtitleConfigSchema.optional(),
+});
+export const runConfigSchema = runDraftSchema.extend({
+    rendered: z.record(z.string(), z.string()),
+});

package/dist/slices/admission/start.js

@@ -1,7 +1,10 @@
 import { transact } from "../../kernel/db/tx.js";
 import { stageKinds } from "../../kernel/pipeline.js";
 import { storeArticleText } from "../article/store.js";
-import { attachStagedFile, dropStagedSource, storeText } from "../storage/staging.js";
+import { admitInitialRevision } from "../rebuild/runtime-admission.js";
+import { adoptBaseline } from "../revisions/adopt.js";
+import { attachStagedFile, storeText } from "../storage/staging.js";
+import { releaseStagedFile } from "../storage/staging-refs.js";
 import { insertProject, insertStage } from "./repo.js";
 // Provide → `provided` with its output attached; Off → `skipped`;
 // everything else → `pending`.
@@ -13,7 +16,7 @@ export function initialState(source) {
 }
 // The project row, its six stages and the provided content all land together or not at
 // all. The caller ticks the runner after this returns, never inside it.
-export function startRun(deps, draft, rendered, retainStaged = false) {
+export function startRun(deps, draft, rendered, retainStaged = false, templates) {
     const id = deps.ids.next();
     const at = deps.clock.now().toISOString();
     const config = { ...draft, rendered };
@@ -50,9 +53,15 @@ export function startRun(deps, draft, rendered, retainStaged = false) {
             insertStage(deps.db, stage);
         }
         attachProvided(deps, id, draft, moved, retainStaged);
+        if (deps.catalogue !== undefined) {
+            const baseline = adoptBaseline(deps, id, templates);
+            if (!baseline.ok)
+                throw new Error("The new project has no revision.");
+            admitInitialRevision(deps, baseline.view, deps.catalogue.read());
+        }
     });
     for (const source of retainStaged ? [] : moved) {
-        dropStagedSource(deps, source);
+        releaseStagedFile(deps, source);
     }
     return { project, stages };
 }
@@ -101,5 +110,5 @@ function attach(deps, projectId, kind, stagedFileId, role, collected, retainStag
         // the file went away between the check and the write.
         throw new Error(`the ${kind} stage's file could not be attached: ${result.reason}`);
     }
-    collected.push(result.stagedSource);
+    collected.push(stagedFileId);
 }

package/dist/slices/article/continuation.js

@@ -43,19 +43,22 @@ export async function writeArticle(providers, choice, brief, onDelta) {
             onDelta(event.text);
         }
     };
-    let answer = await providers.llm({
+    let result = await providers.llm({
         provider: choice.provider,
         model: choice.model,
         ...(choice.thinking === undefined ? {} : { thinking: choice.thinking }),
         messages: base,
         check: written,
     }, stream);
+    if (!result.ok)
+        return result;
+    let answer = result.value;
     const pieces = [answer.text];
     let tokens = plusUsage(noTokens, answer.usage);
     for (let n = 1; truncated(answer) && n <= continuationLimit; n += 1) {
         const messages = continuationMessages(base, pieces.join(""));
         sent.push({ label: `Continuation ${String(n)}`, messages });
-        answer = await providers.llm({
+        result = await providers.llm({
             provider: choice.provider,
             model: choice.model,
             ...(choice.thinking === undefined ? {} : { thinking: choice.thinking }),
@@ -65,10 +68,13 @@ export async function writeArticle(providers, choice, brief, onDelta) {
             // loop therefore never sees a truncated answer with its budget spent.
             check: n === continuationLimit ? finished : written,
         }, stream);
+        if (!result.ok)
+            return result;
+        answer = result.value;
         pieces.push(answer.text);
         tokens = plusUsage(tokens, answer.usage);
     }
-    return { markdown: pieces.join(""), sent, tokens };
+    return { ok: true, value: { markdown: pieces.join(""), sent, tokens } };
 }
 function truncated(answer) {
     return answer.finishReason === truncatedReason;

package/dist/slices/article/provided-entries.js

@@ -14,9 +14,9 @@ export async function prepareProvidedArticleSegments(deps, audioContext, provide
         throw new Error(`project ${projectId} has no row`);
     const { config } = project;
     if (config.sources.article !== "provide" || config.sources.audio !== "generate")
-        return;
+        return "done";
     if (!config.intro && !config.outro)
-        return;
+        return "done";
     audioContext.signal.throwIfAborted();
     const article = stagesOf(deps.db, projectId).find((stage) => stage.kind === "article");
     if (!article)
@@ -36,8 +36,11 @@ export async function prepareProvidedArticleSegments(deps, audioContext, provide
         if (completed.some((piece) => piece.idx === index + 1 && piece.state === "done"))
             continue;
         const sent = [];
-        const segment = await writeSegment(providers, config.llm, config, category, narration, sent);
+        const result = await writeSegment(providers, config.llm, config, category, narration, sent);
         audioContext.signal.throwIfAborted();
+        if (!result.ok)
+            return "held";
+        const segment = result.value;
         if (!segment)
             continue;
         if (sent.length > 0) {
@@ -59,4 +62,5 @@ export async function prepareProvidedArticleSegments(deps, audioContext, provide
             ...segment.tokens,
         });
     }
+    return "done";
 }

package/dist/slices/article/run.js

@@ -24,7 +24,10 @@ export async function runArticle(deps, context, providers) {
     }
     const notes = researchNotes(deps, projectId);
     const brief = { articlePrompt, ...(notes === undefined ? {} : { notes }) };
-    const completed = await articleBody(deps, context, providers, choice, brief);
+    const result = await articleBody(deps, context, providers, choice, brief);
+    if (!result.ok)
+        return "held";
+    const completed = result.value;
     const { narration } = completed;
     const sent = [...completed.sent];
     for (const [index, category] of categories.entries()) {
@@ -33,7 +36,10 @@ export async function runArticle(deps, context, providers) {
         if (completed.resumed &&
             piecesOf(deps.db, context.stage.id, "segment").some((piece) => piece.idx === index + 1 && piece.state === "done"))
             continue;
-        const segment = await writeSegment(providers, choice, project.config, category, narration, sent);
+        const result = await writeSegment(providers, choice, project.config, category, narration, sent);
+        if (!result.ok)
+            return "held";
+        const segment = result.value;
         if (segment !== undefined) {
             keepSegment(deps, context, segment, index + 1);
             checkpointArticle(deps, context, sent);
@@ -60,6 +66,7 @@ export async function runArticle(deps, context, providers) {
         stage: "article",
         detail: `${String(narration.length)} characters to narrate`,
     });
+    return "done";
 }
 // Once the article is stored, a pause during end matter resumes that end matter
 // instead of buying and replacing the article again. Re-run clears this checkpoint.
@@ -82,14 +89,20 @@ async function articleBody(deps, context, providers, choice, brief) {
         existsSync(outputPath(deps.paths, projectId, plain.path)) &&
         existsSync(outputPath(deps.paths, projectId, markdown.path))) {
         return {
-            narration: readFileSync(outputPath(deps.paths, projectId, plain.path), "utf8"),
-            sent: articleCheckpoint.parse(JSON.parse(saved.payload)).sent,
-            resumed: true,
+            ok: true,
+            value: {
+                narration: readFileSync(outputPath(deps.paths, projectId, plain.path), "utf8"),
+                sent: articleCheckpoint.parse(JSON.parse(saved.payload)).sent,
+                resumed: true,
+            },
         };
     }
-    const written = await writeArticle(providers, choice, brief, (text) => {
+    const result = await writeArticle(providers, choice, brief, (text) => {
         context.emit({ type: "article.delta", projectId, text });
     });
+    if (!result.ok)
+        return result;
+    const written = result.value;
     storeText(deps, { projectId, stageKind: "article", role: "article_md", text: written.markdown });
     const narration = storeArticleText(deps, { projectId, markdown: written.markdown });
     checkpointArticle(deps, context, written.sent);
@@ -99,7 +112,7 @@ async function articleBody(deps, context, providers, choice, brief) {
         model: choice.model,
         ...written.tokens,
     });
-    return { narration, sent: written.sent, resumed: false };
+    return { ok: true, value: { narration, sent: written.sent, resumed: false } };
 }
 function checkpointArticle(deps, context, sent) {
     const existing = piecesOf(deps.db, context.stage.id, "article_written")[0];

package/dist/slices/article/segments.js

@@ -4,13 +4,13 @@ export const categories = ["intro", "outro"];
 export async function writeSegment(providers, choice, config, category, article, sent) {
     const picked = config[category];
     if (picked === undefined)
-        return undefined;
+        return { ok: true, value: undefined };
     const body = config.rendered[category];
     if (body === undefined)
         throw new Error(`the run has no rendered ${category} text`);
     const common = { category, name: picked.name, mode: picked.mode };
     if (picked.mode === "text")
-        return { ...common, text: body, tokens: noTokens };
+        return { ok: true, value: { ...common, text: body, tokens: noTokens } };
     if (choice === undefined)
         throw new Error(`the ${category} has no LLM provider or model`);
     const messages = segmentMessages(body, config, article);
@@ -22,9 +22,18 @@ export async function writeSegment(providers, choice, config, category, article,
         messages,
         check: (given) => given.text.trim() === "" ? `the ${category} answered with nothing` : undefined,
     });
-    return { ...common, text: answer.text.trim(), tokens: plusUsage(noTokens, answer.usage) };
+    if (!answer.ok)
+        return answer;
+    return {
+        ok: true,
+        value: {
+            ...common,
+            text: answer.value.text.trim(),
+            tokens: plusUsage(noTokens, answer.value.usage),
+        },
+    };
 }
-function segmentMessages(body, config, article) {
+export function segmentMessages(body, config, article) {
     const values = Object.entries(config.values);
     return [
         {

package/dist/slices/batch/index.js

@@ -3,9 +3,8 @@ import { transact } from "../../kernel/db/tx.js";
 import { derive } from "../../kernel/runner/graph.js";
 import { projectPaused, stagesOf } from "../admission/repo.js";
 import { startRun } from "../admission/start.js";
-import { stagingPath } from "../storage/layout.js";
-import { deleteStagedFile, stagedFileById } from "../storage/repo.js";
-import { dropStagedSource } from "../storage/staging.js";
+import { deleteStagedFile } from "../storage/repo.js";
+import { releaseStagedFile } from "../storage/staging-refs.js";
 const queueRow = z.object({
     projectId: z.string(),
     batchId: z.string(),
@@ -28,7 +27,7 @@ export function queueWaiting(db, projectId) {
 export function batchExists(db, id) {
     return db.prepare("SELECT 1 FROM batches WHERE id = ?").get(id) !== undefined;
 }
-export function enqueueBatch(deps, batchId, runs) {
+export function enqueueBatch(deps, batchId, runs, retainStaged = false) {
     if (batchExists(deps.db, batchId))
         return queueEntries(deps.db, batchId);
     const sources = new Set();
@@ -37,8 +36,8 @@ export function enqueueBatch(deps, batchId, runs) {
             .prepare("INSERT INTO batches(id, created_at) VALUES (?, ?)")
             .run(batchId, deps.clock.now().toISOString());
         const used = new Set();
-        for (const { draft, rendered } of runs) {
-            const { project } = startRun(deps, draft, rendered, true);
+        for (const { draft, rendered, templates } of runs) {
+            const { project } = startRun(deps, draft, rendered, true, templates);
             deps.db
                 .prepare("INSERT INTO project_queue(project_id, batch_id) VALUES (?, ?)")
                 .run(project.id, batchId);
@@ -50,15 +49,13 @@ export function enqueueBatch(deps, batchId, runs) {
                 for (const id of draft.provided.images ?? [])
                     used.add(id);
         }
-        for (const id of used) {
-            const file = stagedFileById(deps.db, id);
-            if (file)
-                sources.add(stagingPath(deps.paths, file.path));
+        for (const id of retainStaged ? [] : used) {
+            sources.add(id);
             deleteStagedFile(deps.db, id);
         }
     });
     for (const source of sources)
-        dropStagedSource(deps, source);
+        releaseStagedFile(deps, source);
     return queueEntries(deps.db, batchId);
 }
 // Only one batch video runs at once. A paused item holds its place; a failed or

package/dist/slices/cancel/index.js

@@ -1,84 +1,128 @@
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { projectStates, stageKinds, } from "../../kernel/pipeline.js";
 import { derive } from "../../kernel/runner/graph.js";
 import { finishStage, projectExists, projectPaused, setProjectPaused, stagesOf, } from "../admission/repo.js";
+import { withProjectControl } from "../control/lock.js";
+import { checkRevisionControl, rememberRevisionControl, } from "../control/revision-control.js";
+import { settleScheduleRunsForProject } from "../schedules/repo.js";
 // Cancel on the project header. Every in-flight call of this project is aborted at once, every
 // `done` output and every finished piece is kept for the resume, and the project sits
 // `canceled` until the user retries a stage.
 // The cancel rules and the stage transition table, in the words the stage row carries.
 export const canceledByUser = "canceled by user";
-export async function cancelProject(deps, projectId) {
+export function cancelProject(deps, projectId, input) {
+    return withProjectControl(deps.db, projectId, async () => {
+        const checked = checkRevisionControl(deps, projectId, "cancel", input, z.object({
+            ok: z.literal(true),
+            canceled: z.array(z.enum(stageKinds)),
+            state: z.enum(projectStates),
+        }));
+        if (!checked.ok)
+            return checked;
+        if (checked.response !== undefined)
+            return checked.response;
+        const result = await cancel(deps, projectId);
+        if (result.ok)
+            rememberRevisionControl(deps, checked.identity, result);
+        return result;
+    });
+}
+async function cancel(deps, projectId) {
     if (!projectExists(deps.db, projectId)) {
         return { ok: false, reason: "no-project" };
     }
     const before = stagesOf(deps.db, projectId);
     const paused = projectPaused(deps.db, projectId);
-    if (paused) {
-        setProjectPaused(deps.db, projectId, false, deps.clock.now().toISOString());
-        deps.emit(projectId, { type: "project.updated", projectId });
-    }
     const running = before.filter((stage) => stage.state === "running").map((stage) => stage.kind);
-    if (running.length === 0 && !paused) {
+    const admittedPending = deps.db
+        .prepare("SELECT 1 FROM revision_work w JOIN revision_work_reservations r ON r.work_id=w.id JOIN project_heads h ON h.project_id=r.project_id AND h.revision_id=r.revision_id WHERE w.project_id=? AND w.state='pending' LIMIT 1")
+        .get(projectId) !== undefined;
+    const draining = deps.hasInflight?.(projectId) === true;
+    if (running.length === 0 && !paused && !admittedPending && !draining) {
         // A second click is a no-op. Nothing is aborted and no state changes, so
         // the page is simply told what the project already reads.
         return { ok: true, canceled: [], state: derive(before) };
     }
     // Nothing waits for a response. The runner holds the controllers and its own
     // barrier, so a stage that finishes during this does not release its dependents.
-    if (running.length > 0)
+    if (running.length > 0 || draining)
         await deps.abort(projectId);
-    // The invariant: after cancel completes no stage of the project is `running`.
-    // The runner writes that row as each aborted stage unwinds; this is the path where it
-    // could not - a failed write is logged there and the run is left mid-flight otherwise.
-    const after = stagesOf(deps.db, projectId);
-    for (const stage of after) {
-        if (stage.state !== "running") {
-            continue;
+    const at = deps.clock.now().toISOString();
+    const transition = transact(deps.db, () => {
+        if (paused)
+            setProjectPaused(deps.db, projectId, false, at);
+        deps.db
+            .prepare("UPDATE revision_work SET state='canceled',dispatch_state='held',failure_reason=? WHERE project_id=? AND state!='done'")
+            .run(canceledByUser, projectId);
+        deps.db
+            .prepare("UPDATE revision_work_pieces SET state='held',dispatch_state='held' WHERE work_id IN (SELECT id FROM revision_work WHERE project_id=?) AND state!='done'")
+            .run(projectId);
+        deps.db
+            .prepare("UPDATE review_checkpoints SET state='canceled',approved_at=NULL WHERE project_id=? AND revision_id=(SELECT revision_id FROM project_heads WHERE project_id=?) AND state IN ('configured','pending-review','held')")
+            .run(projectId, projectId);
+        deps.settleCheckpoints(projectId);
+        // The invariant: after cancel commits no stage of the project is `running`.
+        // Usually the aborted runner already wrote these rows; the sweep covers a failed
+        // unwinding write and shares this transaction with schedule settlement.
+        const after = stagesOf(deps.db, projectId);
+        const swept = [];
+        for (const stage of after) {
+            if (stage.state !== "running")
+                continue;
+            finishStage(deps.db, stage.id, "canceled", canceledByUser, at);
+            swept.push(stage.kind);
         }
+        // An abort can race a successful stage completion. Mark one remaining pending
+        // stage canceled so cancellation is explicit, rather than guessing from any
+        // completed stage (independent images can now finish before Article).
+        const stopped = stagesOf(deps.db, projectId);
+        const waiting = stopped.find((stage) => stage.state === "pending");
+        const waitingCanceled = !stopped.some((stage) => stage.state === "canceled") && waiting !== undefined;
+        if (waitingCanceled)
+            finishStage(deps.db, waiting.id, "canceled", canceledByUser, at);
+        const settled = stagesOf(deps.db, projectId);
+        const state = derive(settled);
+        settleScheduleRunsForProject(deps.db, projectId, at);
+        return { settled, state, swept, waiting: waitingCanceled ? waiting : undefined };
+    });
+    if (paused)
+        deps.emit(projectId, { type: "project.updated", projectId });
+    for (const kind of transition.swept) {
         deps.log.write("warn", "cancel.sweep", {
             projectId,
-            stage: stage.kind,
+            stage: kind,
             detail: "the stage was still running after its calls stopped",
         });
-        finishStage(deps.db, stage.id, "canceled", canceledByUser, deps.clock.now().toISOString());
         deps.emit(projectId, {
             type: "stage.state",
             projectId,
-            stage: stage.kind,
+            stage: kind,
             state: "canceled",
             failureReason: canceledByUser,
         });
     }
-    // An abort can race a successful stage completion. Mark one remaining pending
-    // stage canceled so cancellation is explicit, rather than guessing from any
-    // completed stage (independent images can now finish before Article).
-    const stopped = stagesOf(deps.db, projectId);
-    const waiting = stopped.find((stage) => stage.state === "pending");
-    if (!stopped.some((stage) => stage.state === "canceled") && waiting !== undefined) {
-        finishStage(deps.db, waiting.id, "canceled", canceledByUser, deps.clock.now().toISOString());
+    if (transition.waiting !== undefined)
         deps.emit(projectId, {
             type: "stage.state",
             projectId,
-            stage: waiting.kind,
+            stage: transition.waiting.kind,
             state: "canceled",
             failureReason: canceledByUser,
         });
-    }
-    const settled = stagesOf(deps.db, projectId);
-    const state = derive(settled);
-    if (paused ||
-        after.some((stage) => stage.state === "running") ||
-        (waiting !== undefined && !stopped.some((stage) => stage.state === "canceled"))) {
+    if (paused || transition.swept.length > 0 || transition.waiting !== undefined) {
         // Only when the sweep above moved a row: the runner already announced the state it
         // left the project in, and repeating it would tell every open page the same thing
         // twice.
-        deps.emit(projectId, { type: "project.state", projectId, state });
+        deps.emit(projectId, { type: "project.state", projectId, state: transition.state });
     }
     return {
         ok: true,
         // A stage whose output was stored in the same instant as the cancel stays
         // `done`, so what was stopped is read back rather than assumed from what was running.
-        canceled: settled
+        canceled: transition.settled
             .filter((stage) => stage.state === "canceled" && running.includes(stage.kind))
             .map((stage) => stage.kind),
-        state,
+        state: transition.state,
     };
 }