@gentbajko/slopify 2.5.0 → 3.0.1

package/dist/edge/http/onboarding.js

@@ -0,0 +1,212 @@
+import { randomUUID } from "node:crypto";
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+import { defaultSpeechVoice, detectSpeechCached, primaryLanguage, } from "../../kernel/ports/system-speech.js";
+import { loudnessOfDefault } from "../../slices/loudness/model.js";
+import { firstRunView } from "../../slices/onboarding/first-run.js";
+import { fullVideoDraft } from "../../slices/onboarding/full-video.js";
+import { installPack } from "../../slices/onboarding/install.js";
+import { fullVideoInputSchema, quickShortInputSchema, sampleCopyInputSchema, } from "../../slices/onboarding/model.js";
+import { packById, starterSet } from "../../slices/onboarding/packs.js";
+import { planShortProviders, shortDraft, } from "../../slices/onboarding/quick-short.js";
+import { copySample, restoreSamples, sampleProjectIds, } from "../../slices/onboarding/sample.js";
+import { dismissFirstRun, recordShortRequest, shortRequestProject, } from "../../slices/onboarding/state.js";
+import { systemVoiceProvider } from "../../slices/settings/model.js";
+import { readSettings } from "../../slices/settings/playback.js";
+import { providerStatuses } from "../../slices/settings/readiness.js";
+import { listVoices } from "../../slices/settings/repo.js";
+import { addVoice } from "../../slices/settings/voices.js";
+import { projectTitle } from "../../slices/storage/repo.js";
+import { onInvalid, problem, titleOf } from "./problem.js";
+import { createProject } from "./project-create.js";
+const packParam = z.object({ id: z.string().min(1).max(40) });
+// The first five minutes: the first-run screen's state, starter packs, "Make a 60-second
+// short" and the bundled samples' Restore and Make my own copy.
+export function onboardingRoutes(deps) {
+    const statuses = () => providerStatuses({
+        db: deps.db,
+        probe: deps.probe,
+        hostCliStatus: deps.hostCliStatus,
+        host: deps.speechHost,
+    });
+    const speech = () => detectSpeechCached(deps.probe, deps.speechHost ?? process);
+    // The best speech program found and its English voice, for a short made without a voice key.
+    const systemVoicePick = async () => {
+        const engine = (await speech()).engines[0];
+        const voice = engine === undefined ? undefined : defaultSpeechVoice(engine);
+        return engine === undefined || voice === undefined
+            ? undefined
+            : { model: engine.id, voiceId: voice.id, name: voice.name };
+    };
+    const templates = { ...deps, uuid: randomUUID };
+    const sample = {
+        db: deps.db,
+        paths: deps.paths,
+        clock: deps.clock,
+        ids: deps.ids,
+        log: deps.log,
+        appVersion: deps.version,
+        hasInflight: deps.runner.hasInflight,
+        ...(deps.sampleArchives === undefined ? {} : { archives: deps.sampleArchives }),
+    };
+    return new Hono()
+        .get("/", async (c) => {
+        c.header("Cache-Control", "no-store");
+        return c.json(firstRunView(deps.db, await statuses()));
+    })
+        .post("/dismiss", (c) => {
+        dismissFirstRun(deps.db, deps.clock.now().toISOString());
+        return c.json({ dismissed: true });
+    })
+        .post("/packs/:id", zValidator("param", packParam, onInvalid), (c) => {
+        const installed = installPack(templates, c.req.valid("param").id);
+        if (!installed.ok)
+            return problem(c, {
+                status: 404,
+                title: titleOf(404),
+                detail: "Slopify doesn't have that starter pack. Reload the page and pick one of the packs listed.",
+            });
+        return c.json(installed.value);
+    })
+        .post("/short", zValidator("json", quickShortInputSchema, onInvalid), async (c) => {
+        const input = c.req.valid("json");
+        const earlier = shortRequestProject(deps.db, input.requestId);
+        if (earlier !== undefined && projectTitle(deps.db, earlier) !== undefined)
+            return c.json({ projectId: earlier, replayed: true });
+        const pack = input.packId === undefined ? starterSet : packById(input.packId);
+        if (pack === undefined)
+            return problem(c, {
+                status: 404,
+                title: titleOf(404),
+                detail: "Slopify doesn't have that starter pack. Reload the page and pick one of the packs listed.",
+            });
+        const modelsFor = deps.modelsFor;
+        if (modelsFor === undefined)
+            return problem(c, {
+                status: 503,
+                title: titleOf(503),
+                detail: "Slopify can't list the models on this machine right now. Restart Slopify and try again.",
+            });
+        const plan = await planShortProviders({
+            statuses: await statuses(),
+            voices: listVoices(deps.db),
+            modelsFor,
+            suggested: pack.voice,
+            systemVoice: await systemVoicePick(),
+        });
+        if (!plan.ok)
+            return problem(c, {
+                status: 409,
+                title: titleOf(409),
+                detail: plan.gaps.map((gap) => gap.message).join(" "),
+                extensions: { gaps: plan.gaps },
+            });
+        const installed = installPack(templates, pack.id, { template: false });
+        if (!installed.ok)
+            return problem(c, {
+                status: 404,
+                title: titleOf(404),
+                detail: "Slopify doesn't have that starter pack. Reload the page and pick one of the packs listed.",
+            });
+        // The computer's voice is saved like any other, so Play and a later rebuild offer it.
+        const audio = plan.providers.audio;
+        if (plan.systemVoice &&
+            !listVoices(deps.db).some((voice) => voice.provider === audio.provider && voice.voiceId === audio.voice)) {
+            const found = await speech();
+            const spoken = found.engines
+                .flatMap((engine) => engine.voices)
+                .find((voice) => voice.id === audio.voice);
+            const language = spoken === undefined ? undefined : primaryLanguage(spoken);
+            addVoice({ db: deps.db, ids: deps.ids }, {
+                provider: systemVoiceProvider,
+                name: `${spoken?.name ?? audio.voice} (computer voice)`,
+                voiceId: audio.voice,
+                ...(language === undefined ? {} : { languages: [language] }),
+            });
+        }
+        const created = await createProject(deps, shortDraft({
+            topic: input.topic,
+            pack,
+            names: installed.value.prompts,
+            providers: plan.providers,
+            loudness: loudnessOfDefault(readSettings({ db: deps.db, log: deps.log }).loudness),
+        }));
+        if (!created.ok)
+            return problem(c, {
+                status: created.status,
+                title: titleOf(created.status),
+                detail: `${created.detail} ${created.fields.map((field) => field.message).join(" ")}`.trim(),
+                ...(created.fields.length === 0 ? {} : { extensions: { fields: created.fields } }),
+            });
+        recordShortRequest(deps.db, input.requestId, created.project.id);
+        // A real project now exists, so the first-run screen is done with.
+        dismissFirstRun(deps.db, deps.clock.now().toISOString());
+        return c.json({ projectId: created.project.id, replayed: false }, 201);
+    })
+        .post("/full-video", zValidator("json", fullVideoInputSchema, onInvalid), (c) => {
+        const made = fullVideoDraft(templates, c.req.valid("json"));
+        if (made.ok)
+            return c.json(made.value, 201);
+        if (made.reason === "not-found")
+            return problem(c, {
+                status: 404,
+                title: titleOf(404),
+                detail: "This short or its starter pack is no longer here, so Play couldn't be set up from it. Open Play and pick a template yourself.",
+            });
+        if (made.reason === "not-short")
+            return problem(c, {
+                status: 409,
+                title: titleOf(409),
+                detail: "This project is already a long video. Open Play to start another one on a new topic.",
+            });
+        return problem(c, {
+            status: 409,
+            title: titleOf(409),
+            detail: "Slopify couldn't open a Play draft for the full video. Press Make the full video on this topic again; if it keeps failing, open Play and pick the pack's template in Library → Templates.",
+            extensions: { reason: made.reason },
+        });
+    })
+        .get("/sample", (c) => {
+        const samples = sampleProjectIds(deps.db);
+        return c.json({ projectId: samples.library, samples });
+    })
+        .post("/sample/restore", async (c) => {
+        const restored = await restoreSamples(sample);
+        if (!restored.ok)
+            return problem(c, {
+                status: restored.status,
+                title: titleOf(restored.status),
+                detail: restored.detail,
+            });
+        return c.json({ projectId: restored.samples.library, samples: restored.samples });
+    })
+        .post("/sample/copy", async (c) => {
+        // Which sample to copy is in the body; without one, the Library of Alexandria.
+        const body = await c.req.json().catch(() => ({}));
+        const input = sampleCopyInputSchema.safeParse(body ?? {});
+        if (!input.success)
+            return problem(c, {
+                status: 400,
+                title: titleOf(400),
+                detail: "Slopify couldn't tell which sample to copy. Reload the page and try again.",
+            });
+        const catalogue = deps.catalogue;
+        const id = input.data.projectId ?? sampleProjectIds(deps.db).library ?? undefined;
+        if (catalogue === undefined || id === undefined)
+            return problem(c, {
+                status: 404,
+                title: titleOf(404),
+                detail: "The sample project isn't here. Bring it back with Settings → Backup & storage → Restore samples, then press Make my own copy.",
+            });
+        const copied = copySample({ ...sample, catalogue: catalogue.read() }, id);
+        if (!copied.ok)
+            return problem(c, {
+                status: copied.status,
+                title: titleOf(copied.status),
+                detail: copied.detail,
+            });
+        deps.hub.emitGlobal({ type: "project.updated", projectId: copied.projectId });
+        return c.json({ projectId: copied.projectId }, 201);
+    });
+}

package/dist/edge/http/open-folder.js

@@ -41,7 +41,7 @@ export function openFolderRoutes(deps) {
             return problem(c, {
                 status: 404,
                 title: titleOf(404),
-                detail: "This output's file was deleted or moved. Use Re-run section on the project page to make it again.",
+                detail: "This output's file was deleted or moved. Use More → make it again in its section on the project page to make it again.",
             });
         }
         return replyForFolder(c, deps, id, download.download.path);

package/dist/edge/http/patch-notes.js

@@ -0,0 +1,45 @@
+import { Hono } from "hono";
+import { bundledPatchNotesDir, PatchNotesMissing, readPatchNote, } from "../../slices/patch-notes/library.js";
+import { markPatchNotesSeen, readPatchNotes } from "../../slices/patch-notes/seen.js";
+import { problem, titleOf } from "./problem.js";
+// A build without its notes says so in plain words; anything else is the app's error handler's.
+function missing(c, error) {
+    if (!(error instanceof PatchNotesMissing))
+        throw error;
+    return problem(c, { status: 500, title: titleOf(500), detail: error.message });
+}
+// Settings → Patch notes: the list (with which note is due to open by itself), one note's
+// Markdown, and recording that the note that opened by itself was closed.
+// Preserve Hono's inferred route types for the web client.
+export function patchNotesRoutes(deps) {
+    const dir = deps.patchNotesDir ?? bundledPatchNotesDir();
+    return new Hono()
+        .get("/", async (c) => {
+        try {
+            return c.json(await readPatchNotes(deps.db, dir, deps.version));
+        }
+        catch (error) {
+            return missing(c, error);
+        }
+    })
+        .post("/seen", (c) => {
+        markPatchNotesSeen(deps.db, deps.version);
+        return c.json({ seen: true });
+    })
+        .get("/:id", async (c) => {
+        let markdown;
+        try {
+            markdown = await readPatchNote(dir, c.req.param("id"));
+        }
+        catch (error) {
+            return missing(c, error);
+        }
+        if (markdown === undefined)
+            return problem(c, {
+                status: 404,
+                title: titleOf(404),
+                detail: "These patch notes are not in this version of Slopify. Open Settings → Patch notes and pick one from the list.",
+            });
+        return c.body(markdown, 200, { "content-type": "text/markdown; charset=utf-8" });
+    });
+}

package/dist/edge/http/planning.js

@@ -5,6 +5,7 @@ import { modelFields } from "../../catalog/validate.js";
 import { runDraftSchema } from "../../slices/admission/repo.js";
 import { admit } from "../../slices/admission/rules.js";
 import { batchExists, enqueueBatch, pumpQueue, queueEntries } from "../../slices/batch/index.js";
+import { castVoicedRun } from "../../slices/channels/runs.js";
 import { estimateRun } from "../../slices/estimate/index.js";
 import { resolveFont } from "../../slices/fonts/index.js";
 import { pickTemplates, renderPicked } from "../../slices/library/slots.js";
@@ -32,8 +33,9 @@ export function planningRoutes(deps) {
             title: item.title,
             values: { ...input.draft.values, ...item.values },
         })) ?? [input.draft];
-        return drafts.map((draft, index) => {
-            const picked = pickTemplates(deps.db, draft);
+        return drafts.map((sent, index) => {
+            // Cast speakers take the cast's voices as they are now, as a run started from Play does.
+            const picked = pickTemplates(deps.db, castVoicedRun(deps.db, sent));
             const admitted = admit({
                 draft: picked.draft,
                 staged: stagedFiles(deps.db),

package/dist/edge/http/project-create.js

@@ -0,0 +1,87 @@
+import { modelFields } from "../../catalog/validate.js";
+import { stagesOf } from "../../slices/admission/repo.js";
+import { admit } from "../../slices/admission/rules.js";
+import { startRun } from "../../slices/admission/start.js";
+import { castVoicedRun } from "../../slices/channels/runs.js";
+import { resolveFont } from "../../slices/fonts/index.js";
+import { pickTemplates, renderPicked } from "../../slices/library/slots.js";
+import { stagedFiles } from "../../slices/storage/repo.js";
+import { record } from "../../slices/telemetry/record.js";
+// Starts a project from a whole draft, the way POST /api/projects always has: the prompt
+// bodies are read now, the draft is admitted, the project and its first work are committed in
+// one transaction, and only then is the runner woken. "Make a 60-second short" starts its
+// project through the same door.
+export async function createProject(deps, sent) {
+    // Cast speakers take the cast's voices as they are now, as a run started from Play does.
+    const draft = castVoicedRun(deps.db, sent);
+    if (draft.checkpoints?.length)
+        return {
+            ok: false,
+            status: 409,
+            detail: "This project has checkpoints turned on, so it must be started from Play with Review and start.",
+            fields: [],
+        };
+    const subtitles = draft.subtitles;
+    if (subtitles !== undefined && subtitles.mode !== "off") {
+        try {
+            await resolveFont(deps.paths, subtitles.fontId);
+        }
+        catch {
+            return {
+                ok: false,
+                status: 400,
+                detail: "The subtitle font you picked is no longer available. Choose another font before starting.",
+                fields: [
+                    {
+                        field: "subtitles.fontId",
+                        message: "This font is no longer available. Choose another or upload it again in Settings.",
+                    },
+                ],
+            };
+        }
+    }
+    // The bodies are read here, at the click, so an edit made since the prompt was selected is
+    // the one that runs.
+    const picked = pickTemplates(deps.db, draft);
+    const admitted = admit({
+        draft: picked.draft,
+        staged: stagedFiles(deps.db),
+        requiredSlots: picked.requiredSlots,
+    });
+    const modelErrors = modelFields(picked.draft, deps.catalogue);
+    if (!admitted.ok || picked.missing.length > 0 || modelErrors.length > 0)
+        return {
+            ok: false,
+            status: 400,
+            detail: "This video cannot start yet. Fix the highlighted fields, then try again.",
+            fields: [...picked.missing, ...modelErrors, ...(admitted.ok ? [] : admitted.fields)],
+        };
+    const storage = {
+        catalogue: deps.catalogue,
+        db: deps.db,
+        paths: deps.paths,
+        ids: deps.ids,
+        clock: deps.clock,
+        log: deps.log,
+        emit: (event) => {
+            deps.hub.emitGlobal(event);
+        },
+    };
+    // Rendered from the values admit() has trimmed, so the stored text carries no padding the
+    // user did not intend.
+    const { project } = startRun(storage, admitted.draft, renderPicked(picked, admitted.draft.values), false, Object.fromEntries(picked.bodies.map(({ key, body }) => [key, body])));
+    const telemetry = {
+        db: deps.db,
+        ids: deps.ids,
+        clock: deps.clock,
+        log: deps.log,
+        appVersion: deps.version,
+    };
+    // One event per project created. record() swallows its own failures, so a broken telemetry
+    // write cannot cost the user the run.
+    record(telemetry, "project.created", {});
+    deps.flushSoon();
+    // The run starts only once the project is committed.
+    deps.runner.tick(project.id);
+    return { ok: true, project, stages: stagesOf(deps.db, project.id) };
+}

package/dist/edge/http/project-templates.js

@@ -3,6 +3,7 @@ import { Hono } from "hono";
 import { HTTPException } from "hono/http-exception";
 import { z } from "zod";
 import { createTemplateFromProject, templateFromProjectSchema, } from "../../slices/project-templates/from-project.js";
+import { makeNextChapter, nextChapterSchema } from "../../slices/project-templates/next-chapter.js";
 import { templateCreateSchema, templateDeleteSchema, templateInstantiateSchema, templateUpdateSchema, } from "../../slices/project-templates/schema.js";
 import { createTemplate, deleteTemplate, instantiateTemplate, listTemplates, readTemplate, updateTemplate, } from "../../slices/project-templates/service.js";
 import { onInvalid, problem, titleOf } from "./problem.js";
@@ -37,7 +38,7 @@ function routes(deps) {
             throw new HTTPException(404);
         return deps;
     };
-    return new Hono()
+    return (new Hono()
         .get("/", (c) => c.json({ templates: listTemplates(service()) }))
         .post("/from-project/:projectId", zValidator("param", templateFromProjectSchema.unwrap().pick({ projectId: true }), onInvalid), zValidator("json", templateFromProjectSchema.unwrap().omit({ projectId: true }), onInvalid), (c) => {
         const result = createTemplateFromProject(service(), {
@@ -45,6 +46,22 @@ function routes(deps) {
             projectId: c.req.valid("param").projectId,
         });
         return result.ok ? c.json(result.value, 201) : refused(c, result);
+    })
+        // A finished audiobook chapter's "Make the next chapter": a new Play draft for the book.
+        .post("/next-chapter/:projectId", zValidator("param", nextChapterSchema.unwrap().pick({ projectId: true }), onInvalid), zValidator("json", nextChapterSchema.unwrap().omit({ projectId: true }), onInvalid), (c) => {
+        const result = makeNextChapter(service(), {
+            ...c.req.valid("json"),
+            projectId: c.req.valid("param").projectId,
+        });
+        if (result.ok)
+            return c.json(result.value, 201);
+        const status = result.reason === "not-found" ? 404 : result.reason === "conflict" ? 409 : 400;
+        return problem(c, {
+            status,
+            title: titleOf(status),
+            detail: result.message,
+            extensions: { reason: result.reason },
+        });
     })
         .post("/", zValidator("json", templateCreateSchema, onInvalid), (c) => {
         const result = createTemplate(service(), c.req.valid("json"));
@@ -74,5 +91,5 @@ function routes(deps) {
             templateId: c.req.valid("param").id,
         });
         return result.ok ? c.json(result.value, 201) : refused(c, result);
-    });
+    }));
 }

package/dist/edge/http/projects.js

@@ -1,21 +1,21 @@
 import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
 import { z } from "zod";
-import { modelFields } from "../../catalog/validate.js";
 import { derive, progressOf } from "../../kernel/runner/graph.js";
-import { listProjects, projectById, runDraftSchema, stageStandingsByProject, stagesOf, } from "../../slices/admission/repo.js";
-import { admit } from "../../slices/admission/rules.js";
-import { startRun } from "../../slices/admission/start.js";
+import { listProjects, projectById, projectTrashed, runDraftSchema, stageStandingsByProject, stagesOf, } from "../../slices/admission/repo.js";
+import { defaultChannelId } from "../../slices/channels/model.js";
+import { projectChannels } from "../../slices/channels/repo.js";
 import { withProjectControl } from "../../slices/control/lock.js";
-import { resolveFont } from "../../slices/fonts/index.js";
-import { pickTemplates, renderPicked } from "../../slices/library/slots.js";
+import { stagesWithEta } from "../../slices/eta/view.js";
 import { resumable } from "../../slices/rebuild/recovery-repo.js";
 import { adoptBaseline } from "../../slices/revisions/adopt.js";
 import { currentRevisionId } from "../../slices/revisions/repo.js";
-import { deleteProject } from "../../slices/storage/delete-project.js";
-import { outputsOf, stagedFiles } from "../../slices/storage/repo.js";
-import { record } from "../../slices/telemetry/record.js";
+import { limitWaitsByProject, listingWait } from "../../slices/run-cost/panel.js";
+import { outputsOf } from "../../slices/storage/repo.js";
+import { trashProject } from "../../slices/trash/service.js";
+import { uploadedProjects } from "../../slices/uploads/repo.js";
 import { onInvalid, problem, titleOf } from "./problem.js";
+import { createProject } from "./project-create.js";
 const idParam = z.object({
     id: z
         .string()
@@ -26,28 +26,11 @@ const idParam = z.object({
 // The return type is inferred so Hono keeps the route types the SPA's client is
 // generated from; see stagingRoutes.
 export function projectRoutes(deps) {
-    const storage = {
-        catalogue: deps.catalogue,
+    const storageForTrash = {
         db: deps.db,
         paths: deps.paths,
-        ids: deps.ids,
         clock: deps.clock,
         log: deps.log,
-        emit: (event) => {
-            deps.hub.emitGlobal(event);
-        },
-    };
-    const telemetry = {
-        db: deps.db,
-        ids: deps.ids,
-        clock: deps.clock,
-        log: deps.log,
-        appVersion: deps.version,
-    };
-    const storageForDelete = {
-        db: deps.db,
-        paths: deps.paths,
-        log: deps.log,
         hasInflight: deps.runner.hasInflight,
     };
     const summarise = (project) => ({
@@ -56,76 +39,36 @@ export function projectRoutes(deps) {
     });
     return (new Hono()
         .post("/", zValidator("json", runDraftSchema, onInvalid), async (c) => {
-        if (c.req.valid("json").checkpoints?.length)
-            return problem(c, {
-                status: 409,
-                title: titleOf(409),
-                detail: "This project has checkpoints turned on, so it must be started from Play with Review and start.",
-            });
-        const requestedSubtitles = c.req.valid("json").subtitles;
-        if (requestedSubtitles !== undefined && requestedSubtitles.mode !== "off") {
-            try {
-                await resolveFont(deps.paths, requestedSubtitles.fontId);
-            }
-            catch {
-                return problem(c, {
-                    status: 400,
-                    title: titleOf(400),
-                    detail: "The subtitle font you picked is no longer available. Choose another font before starting.",
-                    extensions: {
-                        fields: [
-                            {
-                                field: "subtitles.fontId",
-                                message: "This font is no longer available. Choose another or upload it again in Settings.",
-                            },
-                        ],
-                    },
-                });
-            }
-        }
-        // The bodies are read here, at the click, so an edit made since the
-        // prompt was selected is the one that runs.
-        const picked = pickTemplates(deps.db, c.req.valid("json"));
-        const admitted = admit({
-            draft: picked.draft,
-            staged: stagedFiles(deps.db),
-            requiredSlots: picked.requiredSlots,
-        });
-        const modelErrors = modelFields(picked.draft, deps.catalogue);
-        if (!admitted.ok || picked.missing.length > 0 || modelErrors.length > 0) {
+        const created = await createProject(deps, c.req.valid("json"));
+        if (!created.ok)
             return problem(c, {
-                status: 400,
-                title: titleOf(400),
-                detail: "This video cannot start yet. Fix the highlighted fields, then try again.",
-                extensions: {
-                    fields: [...picked.missing, ...modelErrors, ...(admitted.ok ? [] : admitted.fields)],
-                },
+                status: created.status,
+                title: titleOf(created.status),
+                detail: created.detail,
+                ...(created.fields.length === 0 ? {} : { extensions: { fields: created.fields } }),
             });
-        }
-        // Rendered from the values admit() has trimmed, so the stored text carries no
-        // padding the user did not intend.
-        const { project } = startRun(storage, admitted.draft, renderPicked(picked, admitted.draft.values), false, Object.fromEntries(picked.bodies.map(({ key, body }) => [key, body])));
-        // One event per project created. record() swallows its own
-        // failures, so a broken telemetry write cannot cost the user the run.
-        record(telemetry, "project.created", {});
-        deps.flushSoon();
-        // The run starts only once the project is committed.
-        deps.runner.tick(project.id);
         // Read back after the tick, not from the rows startRun built: the runner has
         // already claimed every eligible stage, and a body that paired status "running"
         // with "video: pending" would contradict itself.
-        return c.json({ project: summarise(project), stages: stagesOf(deps.db, project.id) }, 201);
+        return c.json({ project: summarise(created.project), stages: stagesOf(deps.db, created.project.id) }, 201);
     })
         // One statement for every project's stage standings, not one per row: the list needs
         // a status word and a meter, and both come out of the same five columns.
         .get("/", (c) => {
         const standings = stageStandingsByProject(deps.db);
+        const channels = projectChannels(deps.db);
+        const uploads = uploadedProjects(deps.db);
+        const waits = limitWaitsByProject(deps.db);
         const projects = listProjects(deps.db).map((project) => {
             const stages = standings.get(project.id) ?? [];
+            const waiting = waits.get(project.id);
             return {
                 ...project,
                 status: derive(stages, project.paused),
                 progress: progressOf(stages),
+                channelId: channels.get(project.id) ?? defaultChannelId,
+                uploadedAt: uploads.get(project.id) ?? null,
+                ...(waiting === undefined ? {} : { limitWaits: waiting.map(listingWait) }),
             };
         });
         return c.json({ projects });
@@ -136,7 +79,9 @@ export function projectRoutes(deps) {
             return problem(c, {
                 status: 404,
                 title: titleOf(404),
-                detail: "This project no longer exists. Go back to Projects to pick another.",
+                detail: projectTrashed(deps.db, c.req.valid("param").id)
+                    ? "This project is in the trash. Restore it in Settings → Trash to open it again."
+                    : "This project no longer exists. Go back to Projects to pick another.",
             });
         }
         if (deps.catalogue !== undefined)
@@ -145,34 +90,26 @@ export function projectRoutes(deps) {
             revisionId: currentRevisionId(deps.db, project.id) ?? null,
             resumable: resumable(deps.db, project.id),
             project: summarise(project),
-            stages: stagesOf(deps.db, project.id),
+            stages: stagesWithEta(deps.db, stagesOf(deps.db, project.id), project.config, deps.clock.now()),
             outputs: outputsOf(deps.db, project.id),
         });
     })
-        // Irreversible, and only from the app: the Projects screen puts a confirmation
-        // dialog in front of it.
+        // Moves the project to the trash (Settings → Trash) for 30 days; removing it for good is
+        // Delete now there, or the daily purge (`slices/trash`).
         .delete("/:id", zValidator("param", idParam, onInvalid), (c) => {
         const id = c.req.valid("param").id;
         return withProjectControl(deps.db, id, () => {
-            const result = deleteProject(storageForDelete, id);
+            const result = trashProject(storageForTrash, id);
             if (result.ok)
                 return c.body(null, 204);
+            const status = result.reason === "running" ? 409 : 404;
             return problem(c, {
-                status: deleteStatus[result.reason],
-                title: titleOf(deleteStatus[result.reason]),
-                detail: result.detail ?? deleteDetails[result.reason],
+                status,
+                title: titleOf(status),
+                detail: result.reason === "running"
+                    ? "This project is still running. Use Cancel run on the project page first, then delete it."
+                    : "This project no longer exists. Go back to Projects to pick another.",
             });
         });
     }));
 }
-const deleteStatus = {
-    "no-project": 404,
-    running: 409,
-    files: 500,
-};
-const deleteDetails = {
-    "no-project": "This project no longer exists. Go back to Projects to pick another.",
-    // The run has to be stopped before its files can go.
-    running: "This project is still running. Use Cancel run on the project page first, then delete it.",
-    files: "Some of this project's files could not be removed. Close any program using files in the project folder, then try deleting again.",
-};