@gentbajko/slopify 0.8.4 → 1.0.0

package/dist/slices/storage/prepare.js

@@ -0,0 +1,67 @@
+import { constants, copyFileSync } from "node:fs";
+import { basename } from "node:path";
+import { allocateAsset, discardPreparedAssets, sealAsset, writeAsset } from "./assets.js";
+import { extensionOf, outputFileName, stagingPath } from "./layout.js";
+import { stagedFileById } from "./repo.js";
+export function prepareStagedFile(deps, input) {
+    const staged = stagedFileById(deps.db, input.stagedFileId);
+    if (staged === undefined)
+        return { ok: false, reason: "unknown-staged-file" };
+    if (staged.state !== "staged")
+        return { ok: false, reason: "still-copying" };
+    const index = input.index ?? 1;
+    const filename = basename(outputFileName(input.role, index, extensionOf(staged.originalFilename), staged.stageKind));
+    const stagedSource = stagingPath(deps.paths, staged.path);
+    const pending = allocateAsset(deps, input.projectId, filename);
+    try {
+        copyFileSync(stagedSource, pending.absolutePath, constants.COPYFILE_EXCL);
+        const asset = sealAsset(deps, pending);
+        return {
+            ok: true,
+            asset,
+            stagedFileId: staged.id,
+            stagedSource,
+            output: {
+                id: deps.ids.next(),
+                projectId: input.projectId,
+                stageKind: staged.stageKind,
+                role: input.role,
+                path: asset.path,
+                originalFilename: staged.originalFilename,
+                bytes: asset.bytes,
+                durationMs: null,
+                meta: input.role === "image" ? { index } : {},
+                createdAt: asset.createdAt,
+            },
+        };
+    }
+    catch (error) {
+        discardPreparedAssets(deps, [pending]);
+        throw error;
+    }
+}
+export function prepareText(deps, input) {
+    const filename = basename(outputFileName(input.role, 1, ".txt", input.stageKind));
+    const asset = writeAsset(deps, input.projectId, filename, Buffer.from(input.text, "utf8"));
+    try {
+        return {
+            asset,
+            output: {
+                id: deps.ids.next(),
+                projectId: input.projectId,
+                stageKind: input.stageKind,
+                role: input.role,
+                path: asset.path,
+                originalFilename: null,
+                bytes: asset.bytes,
+                durationMs: null,
+                meta: {},
+                createdAt: asset.createdAt,
+            },
+        };
+    }
+    catch (error) {
+        discardPreparedAssets(deps, [asset]);
+        throw error;
+    }
+}

package/dist/slices/storage/reconcile.js

@@ -1,14 +1,18 @@
-import { readdirSync, rmSync, unlinkSync } from "node:fs";
+import { readdirSync, rmSync, statSync, unlinkSync } from "node:fs";
 import { join, relative, sep } from "node:path";
-// Files the database does not know about, and staged uploads that never reached a
-// project, are removed at start.
+import { outputPath, stagingPath } from "./layout.js";
+import { stagedFiles as stagedRows } from "./repo.js";
+import { stagedFileReferenced } from "./staging-refs.js";
 export function reconcileStorage(db, paths) {
     const projects = idsOf(db, "SELECT id FROM projects", "id");
     const kept = new Set();
-    for (const row of db.prepare("SELECT project_id, path FROM outputs").all()) {
+    for (const row of db
+        .prepare("SELECT project_id, path FROM outputs UNION SELECT project_id, path FROM project_assets")
+        .all()) {
         const projectId = row.project_id;
         const path = row.path;
         if (typeof projectId === "string" && typeof path === "string") {
+            outputPath(paths, projectId, path);
             kept.add(`${projectId}/${slashed(path)}`);
         }
     }
@@ -47,12 +51,28 @@ export function reconcileStorage(db, paths) {
             orphanFiles += 1;
         }
     }
+    const retained = new Set();
+    for (const file of stagedRows(db)) {
+        if (!stagedFileReferenced(db, file.id))
+            continue;
+        const stat = statSync(stagingPath(paths, file.path), { throwIfNoEntry: false });
+        if (file.state === "staged" && stat?.isFile() && stat.size === file.bytes) {
+            retained.add(file.path);
+            db.prepare("UPDATE play_draft_attachments SET status='ready',error=NULL WHERE staged_file_id=?").run(file.id);
+        }
+        else {
+            db.prepare("UPDATE play_draft_attachments SET staged_file_id=NULL,status='reattach',error=? WHERE staged_file_id=?").run("Upload is missing or incomplete. Reattach the file.", file.id);
+        }
+    }
+    db.prepare("UPDATE play_draft_attachments SET status='reattach',error=? WHERE status IN ('ready','pending') AND staged_file_id IS NULL").run("Upload is missing or incomplete. Reattach the file.");
     let stagedFiles = 0;
     for (const file of filesUnder(paths.staging)) {
+        if (retained.has(file))
+            continue;
         unlinkSync(join(paths.staging, file));
         stagedFiles += 1;
     }
-    db.exec("DELETE FROM staged_files");
+    db.exec("DELETE FROM staged_files WHERE NOT EXISTS (SELECT 1 FROM play_draft_attachments WHERE staged_file_id=staged_files.id)");
     return { orphanFiles, stagedFiles };
 }
 // The one field read inside a payload whose shape belongs to the stage that wrote it: a

package/dist/slices/storage/repo.js

@@ -1,17 +1,6 @@
 import { z } from "zod";
 import { outputRoles, stagedFileStates, stageKinds } from "./model.js";
-const metaSchema = z.object({
-    subtitleOmissions: z
-        .array(z.object({ start: z.number().finite().nonnegative(), text: z.string() }))
-        .optional(),
-    subtitlesMode: z.enum(["off", "files", "burn-in"]).optional(),
-    promptName: z.string().optional(),
-    prompt: z.string().optional(),
-    index: z.number().optional(),
-    provider: z.string().optional(),
-    model: z.string().optional(),
-    voice: z.string().optional(),
-});
+import { metaSchema } from "./schema.js";
 const outputRow = z.object({
     id: z.string(),
     project_id: z.string(),
@@ -46,8 +35,6 @@ export function outputById(db, id) {
     const row = db.prepare("SELECT * FROM outputs WHERE id = ?").get(id);
     return row === undefined ? undefined : toOutput(outputRow.parse(row));
 }
-// An action replaces an output rather than versioning it. The row goes
-// here; the file it names is the caller's to unlink once this has committed.
 export function deleteOutput(db, id) {
     db.prepare("DELETE FROM outputs WHERE id = ?").run(id);
 }
@@ -68,7 +55,7 @@ export function stagedFiles(db) {
         .map((row) => toStagedFile(stagedFileRow.parse(row)));
 }
 export function deleteStagedFile(db, id) {
-    db.prepare("DELETE FROM staged_files WHERE id = ?").run(id);
+    db.prepare("DELETE FROM staged_files WHERE id = ? AND NOT EXISTS (SELECT 1 FROM play_draft_attachments WHERE staged_file_id = ?)").run(id, id);
 }
 export function projectTitle(db, projectId) {
     const row = db.prepare("SELECT title FROM projects WHERE id = ?").get(projectId);

package/dist/slices/storage/schema.js

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { outputRoles, stagedFileStates, stageKinds } from "./model.js";
+export const metaSchema = z.object({
+    subtitleOmissions: z
+        .array(z.object({ start: z.number().finite().nonnegative(), text: z.string() }))
+        .optional(),
+    subtitlesMode: z.enum(["off", "files", "burn-in"]).optional(),
+    promptName: z.string().optional(),
+    prompt: z.string().optional(),
+    index: z.number().optional(),
+    provider: z.string().optional(),
+    model: z.string().optional(),
+    voice: z.string().optional(),
+});
+export const outputSchema = z.object({
+    id: z.string(),
+    projectId: z.string(),
+    stageKind: z.enum(stageKinds),
+    role: z.enum(outputRoles),
+    path: z.string(),
+    originalFilename: z.string().nullable(),
+    bytes: z.number().nonnegative(),
+    durationMs: z.number().nonnegative().nullable(),
+    meta: metaSchema,
+    createdAt: z.string(),
+});
+export const stagedFileSchema = z.object({
+    id: z.string(),
+    stageKind: z.enum(stageKinds),
+    path: z.string(),
+    originalFilename: z.string(),
+    bytes: z.number().nonnegative(),
+    state: z.enum(stagedFileStates),
+    createdAt: z.string(),
+});

package/dist/slices/storage/staging-refs.js

@@ -0,0 +1,26 @@
+import { rmSync } from "node:fs";
+import { stagingPath } from "./layout.js";
+import { deleteStagedFile, stagedFileById } from "./repo.js";
+export function stagedFileReferenced(db, id) {
+    return (db.prepare("SELECT 1 FROM play_draft_attachments WHERE staged_file_id=? LIMIT 1").get(id) !==
+        undefined);
+}
+export function releaseStagedFile(deps, id) {
+    // A nested savepoint cannot prove that its caller will commit. Boot collects deferred releases.
+    if (deps.db.isTransaction || stagedFileReferenced(deps.db, id))
+        return;
+    const file = stagedFileById(deps.db, id);
+    // An active stream owns its open file until completion, including on Windows.
+    if (file?.state === "copying")
+        return;
+    try {
+        rmSync(stagingPath(deps.paths, file?.path ?? id), { force: true });
+    }
+    catch (error) {
+        deps.log.write("warn", "staging.release", {
+            detail: `${id}: ${error instanceof Error ? error.message : String(error)}`,
+        });
+        return;
+    }
+    deleteStagedFile(deps.db, id);
+}

package/dist/slices/storage/staging.js

@@ -1,20 +1,22 @@
 import { copyFileSync, createWriteStream, mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
+import { basename, dirname } from "node:path";
 import { pipeline } from "node:stream/promises";
 import { z } from "zod";
 import { transact } from "../../kernel/db/tx.js";
 import { extensionOf, outputFileName, outputPath, stagingPath } from "./layout.js";
 import { deleteStagedFile, insertOutput, insertStagedFile, markStagedFileCopied, stagedFileById, } from "./repo.js";
+import { releaseStagedFile, stagedFileReferenced } from "./staging-refs.js";
+export { prepareStagedFile, prepareText } from "./prepare.js";
 // The upload's own name is data, never a path component: the file is stored under a
 // generated id, and anything with a separator, a traversal, or a control character is
 // refused rather than sanitised, so nothing silently lands under a name nobody chose.
 const filename = z
     .string()
-    .trim()
+    .refine((name) => name.trim().length > 0)
     .min(1)
     .max(255)
     .refine((name) => !name.includes("/") && !name.includes("\\"))
-    .refine((name) => name !== "." && name !== "..")
+    .refine((name) => name.trim() !== "." && name.trim() !== "..")
     .refine((name) => ![...name].some((character) => (character.codePointAt(0) ?? 0) < 0x20));
 // ceiling: progress is coalesced to one event per 200 ms per upload. A page that wants
 // a smoother bar reads bytes from the staging list instead of asking for more events.
@@ -24,7 +26,7 @@ export async function stageUpload(deps, input) {
     if (!named.success) {
         return { ok: false, reason: "unsafe-filename" };
     }
-    const originalFilename = named.data;
+    const originalFilename = input.originalFilename;
     const id = deps.ids.next();
     const target = stagingPath(deps.paths, id);
     const file = {
@@ -38,7 +40,10 @@ export async function stageUpload(deps, input) {
     };
     // The row exists before the first byte, so a process that dies mid-copy leaves a
     // record reconcile collects rather than an untracked file.
-    insertStagedFile(deps.db, file);
+    transact(deps.db, () => {
+        insertStagedFile(deps.db, file);
+        input.onAllocated?.(file);
+    });
     let bytes = 0;
     let lastEmit = 0;
     const notify = (event) => {
@@ -157,12 +162,7 @@ export function attachStagedFile(deps, input) {
 // has committed. A failure here is not worth failing the run over, because the file is a
 // duplicate of one the project already holds and the next boot's reconcile clears it.
 export function dropStagedSource(deps, source) {
-    try {
-        rmSync(source, { force: true });
-    }
-    catch (error) {
-        deps.log.write("warn", "staging.source", { detail: `${source}: ${messageOf(error)}` });
-    }
+    releaseStagedFile(deps, basename(source));
 }
 // A stage set to Provide can carry pasted text instead of a file, and the project holds it as
 // an output like any other. Unlike an attached upload this needs no two-phase dance: the text
@@ -196,10 +196,15 @@ export function discardStagedFile(deps, id) {
     if (staged === undefined) {
         return { ok: false, reason: "unknown-staged-file" };
     }
+    if (stagedFileReferenced(deps.db, id))
+        return { ok: false, reason: "in-use" };
     discard(deps, id, stagingPath(deps.paths, staged.path), "staging.discarded");
     return { ok: true };
 }
 function discard(deps, id, target, event) {
+    deps.db
+        .prepare("UPDATE play_draft_attachments SET staged_file_id=NULL,status='reattach',error=? WHERE staged_file_id=?")
+        .run("Upload is missing or incomplete. Reattach the file.", id);
     try {
         rmSync(target, { force: true });
     }

package/dist/slices/thumbnail/run.js

@@ -30,9 +30,13 @@ export async function runThumbnail(deps, context, providers) {
         // here is a bug in admission rather than the user's.
         throw new Error("the run has no image provider or model");
     }
-    const written = source === "from_prompt" ? undefined : await byLlm(deps, context, providers, project);
+    const result = source === "from_prompt" ? undefined : await byLlm(deps, context, providers, project);
+    if (result !== undefined && !result.ok)
+        return "held";
+    const written = result?.value;
     const prompt = written?.prompt ?? fromTemplate(project);
-    await make(deps, context, providers, project, choice, prompt);
+    if ((await make(deps, context, providers, project, choice, prompt)) === "held")
+        return "held";
     // Tokens are counted with a provider and model name per stage, and a payload names one
     // provider. This stage can use two - the LLM that writes the prompt and the image model
     // that draws it - so the event names whichever one's usage it reports, because both are
@@ -50,6 +54,7 @@ export async function runThumbnail(deps, context, providers) {
         stage: "thumbnail",
         detail: source === "from_prompt" ? "from the picked prompt" : "from the prompt the LLM wrote",
     });
+    return "done";
 }
 // The rendered thumbnail template goes to the image provider as it is.
 function fromTemplate(project) {
@@ -68,9 +73,12 @@ async function byLlm(deps, context, providers, project) {
         // The wording the user is looking at does not change under them. No call was
         // made, so this run counts none - the run that wrote the prompt already did.
         return {
-            prompt: payloadOf(kept).prompt,
-            ...(llm === undefined ? {} : named(llm)),
-            tokens: noTokens,
+            ok: true,
+            value: {
+                prompt: payloadOf(kept).prompt,
+                ...(llm === undefined ? {} : named(llm)),
+                tokens: noTokens,
+            },
         };
     }
     if (llm === undefined) {
@@ -87,7 +95,9 @@ async function byLlm(deps, context, providers, project) {
         check: (given) => writtenPrompt(given.text),
     });
     // The image prompt is exactly the LLM's output, never edited by the app.
-    const prompt = answer.text.trim();
+    if (!answer.ok)
+        return answer;
+    const prompt = answer.value.text.trim();
     keepWritten(deps, context, kept?.id, prompt, messages);
     // The messages sent are stored beside the article stage's, per stage.
     storeText(deps, {
@@ -96,7 +106,10 @@ async function byLlm(deps, context, providers, project) {
         role: "instructions",
         text: instructionsText(messages),
     });
-    return { prompt, ...named(llm), tokens: plusUsage(noTokens, answer.usage) };
+    return {
+        ok: true,
+        value: { prompt, ...named(llm), tokens: plusUsage(noTokens, answer.value.usage) },
+    };
 }
 function named(choice) {
     return { provider: choice.provider, model: choice.model };
@@ -147,15 +160,18 @@ async function make(deps, context, providers, project, choice, prompt) {
     const { projectId } = context.stage;
     if (outputsOf(deps.db, projectId).some((output) => output.role === "thumbnail")) {
         // The `image-done` sub-step: a retry that failed after the image landed keeps it.
-        return;
+        return "done";
     }
-    const made = await providers.image({
+    const result = await providers.image({
         provider: choice.provider,
         model: choice.model,
         ...(choice.thinking === undefined ? {} : { thinking: choice.thinking }),
         prompt,
         aspect: project.format,
     });
+    if (!result.ok)
+        return "held";
+    const made = result.value;
     const name = outputFileName("thumbnail", 1, made.mime === "image/png" ? ".png" : ".jpg", "thumbnail");
     write(deps, projectId, name, made);
     // A cancel protects an output already stored, not one about to be: one landing between
@@ -184,6 +200,7 @@ async function make(deps, context, providers, project, choice, prompt) {
     // No `image.landed`: the thumbnail stays out of the slideshow, and that event's `index`
     // is a place in it. The stage reaching `done` is what tells the page.
     insertOutput(deps.db, output);
+    return "done";
 }
 function write(deps, projectId, name, made) {
     const target = outputPath(deps.paths, projectId, name);

package/dist/slices/video/audio-export-args.js

@@ -0,0 +1,33 @@
+const rate = 48000;
+export function audioExportArgs(audio, output) {
+    const inputs = audio.flatMap((segment) => segment.path === null
+        ? ["-f", "lavfi", "-t", segment.seconds.toFixed(6), "-i", `anullsrc=r=${rate}:cl=stereo`]
+        : ["-i", segment.path]);
+    const chains = audio.map((_segment, index) => `[${index}:a]aformat=sample_fmts=s16:sample_rates=${rate}:channel_layouts=stereo,asetpts=PTS-STARTPTS[a${index}]`);
+    chains.push(`${audio.map((_segment, index) => `[a${index}]`).join("")}concat=n=${audio.length}:v=0:a=1[a]`);
+    return [
+        "-hide_banner",
+        "-nostdin",
+        "-loglevel",
+        "error",
+        "-progress",
+        "pipe:1",
+        "-nostats",
+        "-y",
+        ...inputs,
+        "-filter_complex",
+        chains.join(";"),
+        "-map",
+        "[a]",
+        "-vn",
+        "-c:a",
+        "pcm_s16le",
+        "-ar",
+        String(rate),
+        "-ac",
+        "2",
+        "-f",
+        "wav",
+        output,
+    ];
+}

package/dist/slices/video/audio-export.js

@@ -1,12 +1,16 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
 import { relative } from "node:path";
-import { projectDir } from "../storage/layout.js";
+import { outputPath, projectDir } from "../storage/layout.js";
 import { outputsOf } from "../storage/repo.js";
 import { prepareSubtitles } from "../subtitles/prepare.js";
+import { audioExportArgs } from "./audio-export-args.js";
 import { audioInputs } from "./audio-inputs.js";
 import { audioTimeline } from "./plan.js";
 import { reusableAudioExport } from "./reuse-audio.js";
 import { writeExport } from "./write-export.js";
 import { writeSubtitles } from "./write-subtitles.js";
+export { audioExportArgs } from "./audio-export-args.js";
 const rate = 48000;
 export async function exportAudioWav(deps, context, gapSeconds) {
     const { projectId } = context.stage;
@@ -15,6 +19,7 @@ export async function exportAudioWav(deps, context, gapSeconds) {
     const audio = audioTimeline({ ...input, gapSeconds }, 1 / rate);
     const totalSeconds = audio.reduce((sum, segment) => sum + segment.seconds, 0);
     const dir = projectDir(deps.paths, projectId);
+    const sources = outputs.filter((output) => ["audio_body", "audio_intro", "audio_outro"].includes(output.role));
     const plan = {
         sampleRate: rate,
         channels: 2,
@@ -26,9 +31,13 @@ export async function exportAudioWav(deps, context, gapSeconds) {
             path: segment.path === null ? null : relative(dir, segment.path),
         })),
         output: "audio.wav",
-        sourceIds: outputs
-            .filter((output) => ["audio_body", "audio_intro", "audio_outro"].includes(output.role))
-            .map((output) => output.id),
+        sourceIds: sources.map((output) => output.id),
+        sourceHashes: sources.map((output) => ({
+            id: output.id,
+            sha256: createHash("sha256")
+                .update(readFileSync(outputPath(deps.paths, projectId, output.path)))
+                .digest("hex"),
+        })),
     };
     const existing = reusableAudioExport(deps.paths, projectId, outputs, plan);
     const subtitles = await prepareSubtitles(deps, context, audio, { width: 1920, height: 1080 });
@@ -46,35 +55,3 @@ export async function exportAudioWav(deps, context, gapSeconds) {
         args: (part) => audioExportArgs(audio, part),
     });
 }
-export function audioExportArgs(audio, output) {
-    const inputs = audio.flatMap((segment) => segment.path === null
-        ? ["-f", "lavfi", "-t", segment.seconds.toFixed(6), "-i", `anullsrc=r=${rate}:cl=stereo`]
-        : ["-i", segment.path]);
-    const chains = audio.map((_segment, index) => `[${index}:a]aformat=sample_fmts=s16:sample_rates=${rate}:channel_layouts=stereo,asetpts=PTS-STARTPTS[a${index}]`);
-    chains.push(`${audio.map((_segment, index) => `[a${index}]`).join("")}concat=n=${audio.length}:v=0:a=1[a]`);
-    return [
-        "-hide_banner",
-        "-nostdin",
-        "-loglevel",
-        "error",
-        "-progress",
-        "pipe:1",
-        "-nostats",
-        "-y",
-        ...inputs,
-        "-filter_complex",
-        chains.join(";"),
-        "-map",
-        "[a]",
-        "-vn",
-        "-c:a",
-        "pcm_s16le",
-        "-ar",
-        String(rate),
-        "-ac",
-        "2",
-        "-f",
-        "wav",
-        output,
-    ];
-}

package/dist/slices/video/audio-inputs.js

@@ -18,10 +18,11 @@ async function audio(deps, outputs, role, dir, signal) {
         return undefined;
     }
     const path = outputPath(deps.paths, output.projectId, output.path);
-    const durationMs = output.durationMs ?? (await probeDurationMs(deps.ffmpeg, path, signal, deps.log));
+    const durationMs = output.durationMs ??
+        (deps.measureAudio === undefined
+            ? await probeDurationMs(deps.ffmpeg, path, signal, deps.log)
+            : await deps.measureAudio(path, signal));
     if (output.durationMs === null) {
-        // A provided file arrives with no duration; measuring it once is worth recording.
-        deps.db.prepare("UPDATE outputs SET duration_ms = ? WHERE id = ?").run(durationMs, output.id);
         deps.log.write("info", "video.probe", {
             projectId: output.projectId,
             stage: "video",

package/dist/slices/video/ffmpeg.js

@@ -217,6 +217,12 @@ export async function probeDurationMs(bin, file, signal, log) {
             "-nostats",
             "-i",
             file,
+            // Older null muxers report the last packet's start, giving short clips zero
+            // duration. One discarded padding sample places that packet at the real end;
+            // current muxers include it, adding less than 1ms at supported audio rates.
+            // Retire when all supported FFmpeg builds report packet ends.
+            "-af",
+            "apad=pad_len=1",
             "-f",
             "null",
             "-",

package/dist/slices/video/reuse-audio.js

@@ -10,6 +10,9 @@ const planSchema = z.object({
     audio: z.array(z.object({ kind: z.string(), path: z.string().nullable(), seconds: z.number() })),
     output: z.string(),
     sourceIds: z.array(z.string()).optional(),
+    sourceHashes: z
+        .array(z.object({ id: z.string(), sha256: z.string().regex(/^[a-f0-9]{64}$/) }))
+        .optional(),
 });
 // Old releases did not record source IDs. Their relative timeline plus source dates and
 // file metadata let subtitle-only edits reuse those exports without a one-time re-encode.
@@ -21,10 +24,12 @@ export function reusableAudioExport(paths, projectId, outputs, plan) {
     let saved;
     try {
         saved = planSchema.parse(JSON.parse(readFileSync(outputPath(paths, projectId, record.path), "utf8")));
-        const { sourceIds: previousIds, ...previousPlan } = saved;
-        const { sourceIds, ...currentPlan } = plan;
+        const { sourceIds: previousIds, sourceHashes: previousHashes, ...previousPlan } = saved;
+        const { sourceIds, sourceHashes, ...currentPlan } = plan;
         if (JSON.stringify(previousPlan) !== JSON.stringify(currentPlan) ||
-            (previousIds !== undefined && JSON.stringify(previousIds) !== JSON.stringify(sourceIds)))
+            (previousIds !== undefined && JSON.stringify(previousIds) !== JSON.stringify(sourceIds)) ||
+            (previousHashes !== undefined &&
+                JSON.stringify(previousHashes) !== JSON.stringify(sourceHashes)))
             return undefined;
         const wav = statSync(outputPath(paths, projectId, media.path));
         if (!wav.isFile() ||
@@ -41,7 +46,9 @@ export function reusableAudioExport(paths, projectId, outputs, plan) {
                 Date.parse(source.createdAt) > Date.parse(media.createdAt))
                 return undefined;
             const file = statSync(outputPath(paths, projectId, source.path));
-            if (!file.isFile() || file.size !== source.bytes || file.mtimeMs > wav.mtimeMs)
+            if (!file.isFile() ||
+                file.size !== source.bytes ||
+                (previousHashes === undefined && file.mtimeMs > wav.mtimeMs))
                 return undefined;
         }
         return media;

package/dist/updater/install-flow.js

@@ -8,6 +8,29 @@ export async function runUpdateFlow(plan, deps) {
         backedUp = true;
         await deps.start(entry);
         await deps.healthy(plan.version);
+    }
+    catch {
+        await deps.stopCandidate();
+        if (backedUp)
+            await deps.restore();
+        await deps.start(plan.oldEntry);
+        await deps.healthy(plan.previousVersion);
+        deps.report("The update did not start; the previous version and database were restored.");
+        throw new Error("The previous Slopify version was restored.");
+    }
+    // Prune before publishing the activation pointer. The candidate's recovery watcher uses
+    // that pointer as its unlock signal, so publishing it first could admit a second update
+    // while this worker is still deleting artifacts. The pruner retains both runnable
+    // versions and the fresh rollback backup, so a later activation failure remains safe.
+    let pruneFailed = false;
+    try {
+        await deps.prune();
+    }
+    catch {
+        // Cleanup is maintenance and must never prevent a healthy candidate from activating.
+        pruneFailed = true;
+    }
+    try {
         await deps.activate();
     }
     catch {
@@ -19,8 +42,10 @@ export async function runUpdateFlow(plan, deps) {
         deps.report("The update did not start; the previous version and database were restored.");
         throw new Error("The previous Slopify version was restored.");
     }
-    // The pointer rename commits the new database. The candidate may already observe
-    // it and accept writes, so a lost unlock acknowledgement can never trigger rollback.
+    if (pruneFailed)
+        deps.report("The update started, but obsolete update files could not be removed.");
+    // The pointer rename commits the new database. A lost unlock acknowledgement cannot
+    // safely roll it back; the candidate's watcher observes the same pointer and recovers.
     await deps.release();
     deps.report(`Slopify ${plan.version} started successfully.`);
 }

package/dist/updater/plan.js

@@ -1,6 +1,6 @@
 import { constants } from "node:fs";
-import { access, readFile, realpath, rename, writeFile } from "node:fs/promises";
-import { delimiter, dirname, join } from "node:path";
+import { access, lstat, readdir, readFile, realpath, rename, rm, writeFile, } from "node:fs/promises";
+import { basename, delimiter, dirname, join, resolve } from "node:path";
 import { z } from "zod";
 import { cliCommand } from "../kernel/cli-command.js";
 import { isStableVersion, isUpdateToken, newerVersion, npmRegistry, updatePackage, } from "./model.js";
@@ -93,6 +93,32 @@ export async function activateUpdate(dataDir, version, token) {
     await writeFile(temporary, JSON.stringify({ version, token }), { mode: 0o600 });
     await rename(temporary, pointer);
 }
+const updateBackup = /^before-(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)-\d+\.db$/;
+export async function pruneUpdateArtifacts(dataDir, currentVersion, rollbackVersion, rollbackBackup) {
+    if (!isStableVersion(currentVersion) || !isStableVersion(rollbackVersion))
+        throw new Error("Invalid retained update version.");
+    const updates = resolve(dataDir, "updates");
+    const backup = resolve(rollbackBackup);
+    const backupName = basename(backup);
+    if (dirname(backup) !== updates || !updateBackup.test(backupName))
+        throw new Error("Invalid retained update backup.");
+    let backupIsFile = false;
+    try {
+        backupIsFile = (await lstat(backup)).isFile();
+    }
+    catch {
+        // Refuse all cleanup unless the rollback database is present as a regular file.
+    }
+    if (!backupIsFile)
+        throw new Error("The retained update backup is missing.");
+    for (const entry of await readdir(updates, { withFileTypes: true })) {
+        const retainedVersion = entry.name === currentVersion || entry.name === rollbackVersion;
+        const obsoleteInstall = isStableVersion(entry.name) && !retainedVersion;
+        const obsoleteBackup = updateBackup.test(entry.name) && entry.name !== backupName;
+        if (obsoleteInstall || obsoleteBackup)
+            await rm(join(updates, entry.name), { recursive: true, force: true });
+    }
+}
 export async function npmCommand() {
     const nodeDir = dirname(process.execPath);
     for (const candidate of [