@gentbajko/slopify 0.8.4 → 1.0.0

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" },
     });
 }

package/dist/edge/http/app.js

@@ -4,19 +4,28 @@ import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
 import { actionRoutes } from "./actions.js";
 import { audioPreviewRoutes } from "./audio-preview.js";
+import { checkpointRoutes } from "./checkpoints.js";
+import { diagnosticsRoutes } from "./diagnostics.js";
+import { draftRoutes } from "./drafts.js";
 import { entryRoutes } from "./entries.js";
 import { fileRoutes } from "./files.js";
 import { fontsRoutes } from "./fonts.js";
 import { openFolderRoutes } from "./open-folder.js";
 import { planningRoutes } from "./planning.js";
 import { problem, problemFromError, titleOf } from "./problem.js";
+import { projectTemplateRoutes } from "./project-templates.js";
 import { projectRoutes } from "./projects.js";
 import { promptRoutes } from "./prompts.js";
 import { providerRoutes } from "./providers.js";
+import { revisionFileRoutes, revisionFolderRoutes } from "./revision-files.js";
+import { revisionRoutes } from "./revisions.js";
+import { scheduleRoutes } from "./schedules.js";
 import { settingsRoutes } from "./settings.js";
 import { stagingRoutes } from "./staging.js";
+import { storageRoutes } from "./storage.js";
 import { subtitleRoutes } from "./subtitles.js";
 import { telemetryRoutes } from "./telemetry.js";
+import { tutorialRoutes } from "./tutorial.js";
 import { updateRoutes } from "./update.js";
 import { usageRoutes } from "./usage.js";
 const notBuilt = "The Slopify UI is not built yet. The API is running: try /api/health.\n" +
@@ -29,8 +38,16 @@ function apiRoutes(deps, startedAt) {
         uptimeMs: deps.clock.now().getTime() - startedAt,
     }))
         .route("/staging", stagingRoutes(deps))
+        .route("/storage", storageRoutes(deps))
+        .route("/drafts", draftRoutes(deps.drafts))
+        .route("/diagnostics", diagnosticsRoutes(deps))
+        .route("/project-templates", projectTemplateRoutes(deps.drafts))
+        .route("/schedules", scheduleRoutes(deps.schedules))
         .route("/projects", planningRoutes(deps))
         .route("/projects", projectRoutes(deps))
+        .route("/projects", checkpointRoutes(deps))
+        .route("/projects", revisionRoutes(deps))
+        .route("/projects", revisionFolderRoutes(deps))
         .route("/projects", openFolderRoutes(deps))
         .route("/projects", audioPreviewRoutes(deps))
         .route("/update", updateRoutes(deps))
@@ -44,6 +61,7 @@ function apiRoutes(deps, startedAt) {
         .route("/telemetry", telemetryRoutes(deps))
         .route("/usage", usageRoutes(deps))
         .route("/settings", settingsRoutes(deps))
+        .route("/tutorial", tutorialRoutes(deps))
         .route("/providers", providerRoutes(deps)));
 }
 export function createApp(deps) {
@@ -56,22 +74,36 @@ export function createApp(deps) {
         await next();
     })
         .use("/api/*", async (c, next) => {
-        if (deps.updater === undefined ||
-            ["GET", "HEAD", "OPTIONS"].includes(c.req.method) ||
-            ["/api/update", "/api/update/", "/api/update/activate", "/api/update/activate/"].includes(c.req.path))
+        if (["GET", "HEAD", "OPTIONS"].includes(c.req.method))
             return next();
-        const release = deps.updater.beginMutation();
-        if (release === undefined)
+        const releaseRequest = deps.mutations?.begin();
+        if (deps.mutations !== undefined && releaseRequest === undefined)
+            return problem(c, {
+                status: 503,
+                title: titleOf(503),
+                detail: "Slopify is shutting down. Wait for it to restart before making changes.",
+            });
+        const updateRoute = [
+            "/api/update",
+            "/api/update/",
+            "/api/update/activate",
+            "/api/update/activate/",
+        ].includes(c.req.path);
+        const releaseUpdate = deps.updater === undefined || updateRoute ? undefined : deps.updater.beginMutation();
+        if (deps.updater !== undefined && !updateRoute && releaseUpdate === undefined) {
+            releaseRequest?.();
             return problem(c, {
                 status: 409,
                 title: titleOf(409),
                 detail: "Slopify is updating. Wait for it to restart before making changes.",
             });
+        }
         try {
             await next();
         }
         finally {
-            release();
+            releaseUpdate?.();
+            releaseRequest?.();
         }
     })
         .onError((error, c) => problemFromError(c, error, deps))
@@ -81,6 +113,7 @@ export function createApp(deps) {
         .get("/api/events/projects/:id", (c) => streamSSE(c, (stream) => deps.hub.subscribe(c.req.param("id"), stream, c.req.raw.signal)))
         // Files are served by URL, not through the API.
         .route("/", fileRoutes(deps))
+        .route("/", revisionFileRoutes(deps))
         // The API answers for its whole prefix, so an unknown endpoint is a problem+json 404
         // rather than the SPA's index.html with a 200.
         .all("/api/*", missing);

package/dist/edge/http/audio-preview.js

@@ -1,7 +1,9 @@
 import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
 import { z } from "zod";
+import { currentRevisionId } from "../../slices/revisions/repo.js";
 import { projectTitle } from "../../slices/storage/repo.js";
+import { currentWorkOrigin } from "../events/visibility.js";
 import { onInvalid, problem, titleOf } from "./problem.js";
 const projectParam = z.object({
     projectId: z
@@ -18,12 +20,18 @@ export function audioPreviewRoutes(deps) {
         if (projectTitle(deps.db, projectId) === undefined)
             return missing(c);
         c.header("Cache-Control", "no-store");
-        return c.json({ previews: deps.audioPreviews?.list(projectId) ?? [] });
+        return c.json({
+            revisionId: currentRevisionId(deps.db, projectId) ?? null,
+            previews: (deps.audioPreviews?.list(projectId) ?? []).filter((preview) => currentWorkOrigin(deps.db, projectId, preview)),
+        });
     })
         .get("/:projectId/audio-preview/:previewId", zValidator("param", previewParam, onInvalid), (c) => {
         const { projectId, previewId } = c.req.valid("param");
         if (projectTitle(deps.db, projectId) === undefined)
             return missing(c);
+        const preview = deps.audioPreviews?.list(projectId).find((item) => item.id === previewId);
+        if (preview === undefined || !currentWorkOrigin(deps.db, projectId, preview))
+            return missing(c);
         const stream = deps.audioPreviews?.stream(projectId, previewId, c.req.raw.signal);
         if (stream === undefined)
             return missing(c);