@gentbajko/slopify 0.6.1 → 0.8.0

package/dist/slices/narration/plan.js

@@ -0,0 +1,58 @@
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { splitText } from "../../kernel/ports/text.js";
+import { insertPiece, piecesOf } from "../../kernel/runner/piece-repo.js";
+const payload = z.object({ text: z.string(), file: z.string().optional() });
+// Old whole-text plans can exceed a newly known account limit. Preserve finished
+// pieces and their paths, and split only unfinished work before any request starts.
+export function planNarration(deps, stageId, texts, maxCharacters, finished) {
+    const old = piecesOf(deps.db, stageId, "chunk");
+    const source = old.length
+        ? old
+        : texts.map((text, idx) => ({
+            id: deps.ids.next(),
+            stageId,
+            kind: "chunk",
+            idx: idx + 1,
+            state: "pending",
+            payload: JSON.stringify({ text }),
+        }));
+    const planned = [];
+    for (const piece of source) {
+        const data = payload.parse(JSON.parse(piece.payload ?? "null"));
+        if (finished(piece)) {
+            planned.push({ ...piece, idx: planned.length + 1 });
+            continue;
+        }
+        for (const [part, text] of splitText(data.text, maxCharacters).entries())
+            planned.push({
+                ...piece,
+                id: part === 0 ? piece.id : deps.ids.next(),
+                idx: planned.length + 1,
+                state: "pending",
+                payload: JSON.stringify({ text }),
+            });
+    }
+    if (old.length &&
+        planned.length === old.length &&
+        planned.every((p, i) => p.id === old[i]?.id &&
+            payload.parse(JSON.parse(p.payload ?? "null")).text ===
+                payload.parse(JSON.parse(old[i]?.payload ?? "null")).text))
+        return old;
+    transact(deps.db, () => {
+        // Negative temporary indices avoid colliding with a retained completed piece.
+        deps.db
+            .prepare("UPDATE stage_pieces SET idx=-idx WHERE stage_id=? AND kind='chunk'")
+            .run(stageId);
+        const known = new Set(old.map((p) => p.id));
+        for (const piece of planned) {
+            if (known.has(piece.id))
+                deps.db
+                    .prepare("UPDATE stage_pieces SET idx=?,state=?,payload=? WHERE id=?")
+                    .run(piece.idx, piece.state, piece.payload, piece.id);
+            else
+                insertPiece(deps.db, piece);
+        }
+    });
+    return planned;
+}

package/dist/slices/narration/run.js

@@ -1,8 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 import { z } from "zod";
-import { transact } from "../../kernel/db/tx.js";
-import { insertPiece, piecesOf, setPiece } from "../../kernel/runner/piece-repo.js";
+import { piecesOf, setPiece } from "../../kernel/runner/piece-repo.js";
 import { entryModes } from "../admission/model.js";
 import { projectById, setStageProgress, stagesOf } from "../admission/repo.js";
 import { entryCategories } from "../library/model.js";
@@ -11,6 +10,8 @@ import { insertOutput, outputsOf } from "../storage/repo.js";
 import { probeDurationMs } from "../video/ffmpeg.js";
 import { chunkNarration, defaultChunking } from "./chunk.js";
 import { joinNarration } from "./concat.js";
+import { observeNarration } from "./live.js";
+import { planNarration } from "./plan.js";
 // An empty narration source fails the stage immediately with no retries. Thrown from the
 // slice rather than from a provider call, so the attempt wrapper never sees it.
 export const nothingToNarrate = "nothing to narrate";
@@ -31,6 +32,7 @@ const segmentPayload = z.object({
 const chunkDir = "audio-chunks";
 export async function runNarration(deps, context, providers) {
     const { projectId } = context.stage;
+    deps.audioPreviews?.clear(projectId);
     const project = projectById(deps.db, projectId);
     if (project === undefined) {
         throw new Error(`project ${projectId} has no row`);
@@ -51,7 +53,8 @@ export async function runNarration(deps, context, providers) {
     if (texts.length === 0) {
         throw new Error(nothingToNarrate);
     }
-    const files = await speakChunks(deps, context, providers, choice, plan(deps, context, texts));
+    const planned = planNarration(deps, context.stage.id, texts, deps.maxCharacters?.(choice.provider, choice.model) ?? 1000000, (piece) => finished(deps, projectId, piece) !== undefined);
+    const files = await speakChunks(deps, context, providers, choice, planned);
     await storeBody(deps, context, choice, files, outputs);
     await speakSegments(deps, context, providers, choice, outputs);
     deps.log.write("info", "narration.done", {
@@ -69,29 +72,7 @@ function narrationSource(deps, outputs, projectId) {
     }
     return readFileSync(outputPath(deps.paths, projectId, article.path), "utf8");
 }
-// The chunk list, planned once and kept. A retry after a failure finds the rows the first
-// run wrote and narrates only the ones that did not finish.
-function plan(deps, context, texts) {
-    const existing = piecesOf(deps.db, context.stage.id, "chunk");
-    if (existing.length > 0) {
-        return existing;
-    }
-    const planned = texts.map((text, index) => ({
-        id: deps.ids.next(),
-        stageId: context.stage.id,
-        kind: "chunk",
-        idx: index + 1,
-        state: "pending",
-        payload: JSON.stringify({ text }),
-    }));
-    transact(deps.db, () => {
-        for (const piece of planned) {
-            insertPiece(deps.db, piece);
-        }
-    });
-    return planned;
-}
-// Every chunk is synthesized in parallel. A chunk a previous run finished is not spoken
+// Chunks are scheduled through the shared provider queue. A chunk a previous run finished is not spoken
 // again, and one that fails takes down the whole stage while its siblings finish and keep their
 // audio for the next resume.
 async function speakChunks(deps, context, providers, choice, pieces) {
@@ -105,14 +86,15 @@ async function speakChunks(deps, context, providers, choice, pieces) {
         if (kept !== undefined) {
             return { ok: true, file: kept };
         }
-        const file = `${chunkDir}/${String(piece.idx).padStart(3, "0")}.mp3`;
+        const file = `${chunkDir}/${piece.id}.mp3`;
         setPiece(deps.db, piece.id, "running", piece.payload);
         try {
             const spoken = await providers.forPiece(piece.id).tts({
                 provider: choice.provider,
+                model: choice.model,
                 voiceId: choice.voice,
                 text: carried.text,
-            });
+            }, observeNarration(deps.audioPreviews, projectId, piece.id, total === 1 ? "Body" : `Body part ${piece.idx} of ${total}`));
             write(deps, projectId, file, spoken.bytes);
             // The file is on disk before the row says so: a crash between the two leaves a
             // file the reconcile collects, where the other order would leave a `done` chunk
@@ -180,9 +162,10 @@ async function speakSegments(deps, context, providers, choice, outputs) {
         }
         const spoken = await providers.forPiece(piece.id).tts({
             provider: choice.provider,
+            model: choice.model,
             voiceId: choice.voice,
             text,
-        });
+        }, observeNarration(deps.audioPreviews, projectId, piece.id, segment.category === "intro" ? "Intro" : "Outro"));
         const name = outputFileName(role, 1, ".mp3", "audio");
         write(deps, projectId, name, spoken.bytes);
         // Measured the same way the body is, because the render adds all three and the gaps to
@@ -208,14 +191,13 @@ function segmentPieces(deps, projectId) {
     }
     return piecesOf(deps.db, article.id, "segment");
 }
-// Audio seconds come from the measured duration per segment, never from the text's length:
-// the real duration goes on the row and the video timeline is built from it. No model is
-// named because the TTS port carries none - the same reason `store` above leaves it off.
+// Audio seconds come from the measured duration per segment, never from the text's length.
 function counted(deps, segment, durationMs, choice) {
     deps.count("stage.completed", {
         stage: "audio",
         segment,
         provider: choice.provider,
+        model: choice.model,
         audioSeconds: durationMs / 1000,
     });
 }
@@ -246,9 +228,6 @@ function write(deps, projectId, path, bytes) {
     mkdirSync(dirname(target), { recursive: true, mode: 0o700 });
     writeFileSync(target, bytes, { mode: 0o600 });
 }
-// The provider and the voice are stored with the audio they made. The model is not:
-// the TTS port carries no model, so every request went to the adapter's own, and writing
-// the run's dropdown value here would record something that was never sent.
 function store(deps, projectId, role, path, durationMs, choice) {
     insertOutput(deps.db, {
         id: deps.ids.next(),
@@ -259,7 +238,7 @@ function store(deps, projectId, role, path, durationMs, choice) {
         originalFilename: null,
         bytes: statSync(outputPath(deps.paths, projectId, path)).size,
         durationMs,
-        meta: { provider: choice.provider, voice: choice.voice },
+        meta: { provider: choice.provider, model: choice.model, voice: choice.voice },
         createdAt: deps.clock.now().toISOString(),
     });
 }

package/dist/slices/research/run.js

@@ -52,7 +52,9 @@ async function research(deps, context, providers, choice, brief) {
     const answer = await providers.llm({
         provider: choice.provider,
         model: choice.model,
+        ...(choice.thinking === undefined ? {} : { thinking: choice.thinking }),
         messages: synthesisMessages(brief, findings),
+        previewLabel: "Writing research notes",
         check: (given) => sourcedAnswer("the synthesis", given.text),
     });
     add(answer.usage);
@@ -70,6 +72,7 @@ async function research(deps, context, providers, choice, brief) {
         stage: "research",
         provider: choice.provider,
         model: choice.model,
+        ...(choice.thinking === undefined ? {} : { thinking: choice.thinking }),
         ...tokens,
     });
     deps.log.write("info", "research.done", {
@@ -88,7 +91,9 @@ async function plan(deps, context, providers, choice, brief, add) {
     const answer = await providers.llm({
         provider: choice.provider,
         model: choice.model,
+        ...(choice.thinking === undefined ? {} : { thinking: choice.thinking }),
         messages: plannerMessages(brief),
+        previewLabel: "Planning research",
         // An empty answer, or one with no chapter in it, is a failed attempt.
         check: (given) => chaptersFrom(given.text).length === 0 ? "the planner named no chapters" : undefined,
     });
@@ -128,7 +133,9 @@ async function researchChapters(deps, context, providers, choice, brief, chapter
             const answer = await providers.forPiece(piece.id).llm({
                 provider: choice.provider,
                 model: choice.model,
+                ...(choice.thinking === undefined ? {} : { thinking: choice.thinking }),
                 messages: subAgentMessages(brief, kept.title, outline),
+                previewLabel: kept.title,
                 // Grounding is asked for explicitly, so a model without it says so
                 // instead of answering from what it already knows.
                 webSearch: true,

package/dist/slices/settings/model.js

@@ -12,6 +12,7 @@ export const providerIds = [
     "elevenlabs",
     "openai-tts",
     "cartesia",
+    "inworld",
     "fal",
     "replicate",
     "openai-image",
@@ -46,6 +47,7 @@ export const providers = [
     { id: "elevenlabs", family: "tts", displayName: "ElevenLabs", auth: "key" },
     { id: "openai-tts", family: "tts", displayName: "OpenAI", auth: "key" },
     { id: "cartesia", family: "tts", displayName: "Cartesia", auth: "key" },
+    { id: "inworld", family: "tts", displayName: "Inworld", auth: "key" },
     { id: "fal", family: "image", displayName: "fal.ai", auth: "key" },
     { id: "replicate", family: "image", displayName: "Replicate", auth: "key" },
     { id: "openai-image", family: "image", displayName: "OpenAI", auth: "key" },

package/dist/slices/settings/models.js

@@ -0,0 +1,89 @@
+// These marketplaces host models with different input schemas. Discovery alone cannot
+// make an arbitrary endpoint compatible with our image request.
+export function allowsCustomModel(provider) {
+    return provider !== "fal" && provider !== "replicate";
+}
+const ttlMs = 5 * 60_000;
+const retryMs = 30_000;
+export function createModelCatalog(deps) {
+    const cache = new Map();
+    const pending = new Map();
+    const generations = new Map();
+    async function get(provider, family, refresh = false) {
+        const active = pending.get(provider);
+        if (active !== undefined)
+            return active;
+        const previous = cache.get(provider);
+        if (!refresh && previous !== undefined && previous.expires > deps.now())
+            return previous.value;
+        const generation = generations.get(provider) ?? 0;
+        const task = Promise.resolve()
+            .then(async () => {
+            let value;
+            let lifetime = ttlMs;
+            try {
+                const models = await deps.load(provider, family);
+                value = {
+                    models: uniqueModels(models),
+                    allowsCustom: allowsCustomModel(provider),
+                    ...catalogNotice(provider),
+                };
+            }
+            catch {
+                // A catalogue is metadata, not generation. Never expose an upstream response
+                // here: it can quote credentials that belong only inside its adapter.
+                deps.report(provider);
+                const saved = previous?.value.models;
+                value = {
+                    models: saved ?? deps.fallback(provider),
+                    ...catalogNotice(provider),
+                    allowsCustom: allowsCustomModel(provider),
+                    warning: saved === undefined
+                        ? "Could not load the model list. Showing bundled choices; refresh to try again."
+                        : "Could not refresh the model list. Showing the last loaded choices.",
+                };
+                lifetime = retryMs;
+            }
+            if ((generations.get(provider) ?? 0) === generation) {
+                cache.set(provider, { value, expires: deps.now() + lifetime });
+            }
+            return value;
+        })
+            .finally(() => {
+            if (pending.get(provider) === task)
+                pending.delete(provider);
+        });
+        pending.set(provider, task);
+        return task;
+    }
+    return {
+        get,
+        invalidate: (provider) => {
+            generations.set(provider, (generations.get(provider) ?? 0) + 1);
+            cache.delete(provider);
+            pending.delete(provider);
+        },
+    };
+}
+function uniqueModels(models) {
+    const seen = new Set();
+    return models.filter((model) => {
+        if (model.id.trim() === "" || seen.has(model.id))
+            return false;
+        seen.add(model.id);
+        return true;
+    });
+}
+function catalogNotice(provider) {
+    const notices = {
+        codex: "Models come from Codex's local catalogue. Open Codex to refresh that catalogue, then refresh this list.",
+        gemini: "Models and aliases come from the installed Gemini CLI. Update that CLI to discover newer models.",
+        "claude-code": "These aliases follow Claude Code's model families. You can also enter an exact model ID.",
+        inworld: "These are Inworld’s documented TTS models. You can also enter a compatible model ID.",
+        cartesia: "Cartesia has no model-list API. These are bundled compatible choices; you can enter a newer model ID.",
+        fal: "These models have input formats supported by Slopify's fal adapter.",
+        replicate: "These models have input formats supported by Slopify's Replicate adapter.",
+    };
+    const notice = Object.hasOwn(notices, provider) ? notices[provider] : undefined;
+    return notice === undefined ? {} : { notice };
+}

package/dist/slices/storage/staging.js

@@ -140,7 +140,8 @@ export function attachStagedFile(deps, input) {
     try {
         transact(deps.db, () => {
             insertOutput(deps.db, output);
-            deleteStagedFile(deps.db, staged.id);
+            if (!input.retainStaged)
+                deleteStagedFile(deps.db, staged.id);
         });
     }
     catch (error) {

package/dist/slices/subtitles/captions.js

@@ -1,3 +1,4 @@
+import { subtitlePlacement } from "./layout.js";
 // Keep spoken spelling and punctuation. Word times come only from acoustic alignment.
 export function captionCues(words) {
     const cues = [];
@@ -61,10 +62,12 @@ export function serializeVtt(cues) {
 }
 export function serializeAss(cues, style) {
     const name = style.fontName.replace(/[\p{Cc},]/gu, " ").trim();
+    const placement = subtitlePlacement(style.position ?? "bottom", style.height);
+    const position = `{\\an${placement.alignment}\\pos(${style.width / 2},${placement.y})}`;
     const header = `[Script Info]\nScriptType: v4.00+\nPlayResX: ${style.width}\nPlayResY: ${style.height}\nWrapStyle: 0\nScaledBorderAndShadow: yes\n\n[V4+ Styles]\nFormat: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding\nStyle: Default,${name},${style.fontSize},&H00FFFFFF,&H00FFFFFF,&H00101010,&H80000000,0,0,0,0,100,100,0,0,1,2.5,1,2,60,60,60,1\n\n[Events]\nFormat: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text\n`;
     return (header +
         cues
-            .map((cue) => `Dialogue: 0,${assStamp(cue.start)},${assStamp(cue.end)},Default,,0,0,0,,${assText(cue.text)}\n`)
+            .map((cue) => `Dialogue: 0,${assStamp(cue.start)},${assStamp(cue.end)},Default,,0,0,0,,${position}${assText(cue.text)}\n`)
             .join(""));
 }
 function markup(text) {

package/dist/slices/subtitles/layout.js

@@ -0,0 +1,19 @@
+export function subtitleFrame(format) {
+    return format === "9:16" ? { width: 1080, height: 1920 } : { width: 1920, height: 1080 };
+}
+// ASS and the browser preview share anchors. Edge positions keep the existing
+// 60-pixel safe margin; interior positions center both single and multiline cues.
+export function subtitlePlacement(position, height) {
+    switch (position) {
+        case "top":
+            return { y: 60, alignment: 8, translateY: 0 };
+        case "upper-middle":
+            return { y: height / 4, alignment: 5, translateY: -50 };
+        case "center":
+            return { y: height / 2, alignment: 5, translateY: -50 };
+        case "lower-middle":
+            return { y: (height * 3) / 4, alignment: 5, translateY: -50 };
+        case "bottom":
+            return { y: height - 60, alignment: 2, translateY: -100 };
+    }
+}

package/dist/slices/subtitles/model.js

@@ -1,5 +1,12 @@
 import { z } from "zod";
 export const subtitleModes = ["off", "files", "burn-in"];
+export const subtitlePositions = [
+    "top",
+    "upper-middle",
+    "center",
+    "lower-middle",
+    "bottom",
+];
 export const subtitleConfigSchema = z.object({
     mode: z.enum(subtitleModes),
     language: z.literal("en").default("en"),
@@ -8,6 +15,7 @@ export const subtitleConfigSchema = z.object({
         .max(160)
         .regex(/^[A-Za-z0-9_-]+$/)
         .default("default"),
+    position: z.enum(subtitlePositions).default("bottom"),
     fontSize: z.number().int().min(16).max(120).default(48),
 });
 export const defaultSubtitles = {
@@ -15,4 +23,5 @@ export const defaultSubtitles = {
     language: "en",
     fontId: "default",
     fontSize: 48,
+    position: "bottom",
 };

package/dist/slices/subtitles/prepare.js

@@ -59,7 +59,12 @@ export async function prepareSubtitles(deps, context, audio, frame) {
             throw new Error("No spoken words could be aligned. Check that the English article matches the audio.");
         writeFileSync(join(directory, "subtitles.srt"), serializeSrt(cues), { mode: 0o600 });
         writeFileSync(join(directory, "subtitles.vtt"), serializeVtt(cues), { mode: 0o600 });
-        writeFileSync(join(directory, "subtitles.ass"), serializeAss(cues, { ...frame, fontSize: config.fontSize, fontName: font.assName }), { mode: 0o600 });
+        writeFileSync(join(directory, "subtitles.ass"), serializeAss(cues, {
+            ...frame,
+            fontSize: config.fontSize,
+            fontName: font.assName,
+            position: config.position,
+        }), { mode: 0o600 });
         writeFileSync(join(directory, "subtitles.json"), JSON.stringify({ key, words, font }), {
             mode: 0o600,
         });

package/dist/slices/thumbnail/run.js

@@ -81,6 +81,7 @@ async function byLlm(deps, context, providers, project) {
     const answer = await providers.llm({
         provider: llm.provider,
         model: llm.model,
+        ...(llm.thinking === undefined ? {} : { thinking: llm.thinking }),
         messages,
         // An empty answer is a failed attempt, and the wrapper is what retries it.
         check: (given) => writtenPrompt(given.text),
@@ -151,6 +152,7 @@ async function make(deps, context, providers, project, choice, prompt) {
     const made = await providers.image({
         provider: choice.provider,
         model: choice.model,
+        ...(choice.thinking === undefined ? {} : { thinking: choice.thinking }),
         prompt,
         aspect: project.format,
     });
@@ -175,6 +177,7 @@ async function make(deps, context, providers, project, choice, prompt) {
             prompt,
             provider: choice.provider,
             model: choice.model,
+            ...(choice.thinking === undefined ? {} : { thinking: choice.thinking }),
         },
         createdAt: deps.clock.now().toISOString(),
     };

package/dist/updater/candidate.js

@@ -0,0 +1,28 @@
+export function watchActivation(updater, token, expired, report) {
+    let checking = false;
+    const until = Date.now() + 120_000;
+    const timer = setInterval(() => {
+        if (checking)
+            return;
+        checking = true;
+        void updater
+            .activate(token)
+            .then(async (activated) => {
+            if (activated)
+                clearInterval(timer);
+            else if (Date.now() >= until) {
+                clearInterval(timer);
+                report("The update was not committed; stopping the candidate server.");
+                await expired();
+            }
+        })
+            .catch(() => {
+            report("The update activation marker could not be checked.");
+        })
+            .finally(() => {
+            checking = false;
+        });
+    }, 250);
+    timer.unref();
+    return () => clearInterval(timer);
+}

package/dist/updater/forward.js

@@ -0,0 +1,35 @@
+import { spawn } from "node:child_process";
+import { activeUpdateEntry } from "./plan.js";
+export async function forwardManagedUpdate(dataDir, version, args) {
+    if (process.env.SLOPIFY_SKIP_MANAGED_UPDATE === "1")
+        return undefined;
+    const entry = await activeUpdateEntry(dataDir, version);
+    if (entry === undefined)
+        return undefined;
+    return new Promise((resolve) => {
+        const child = spawn(process.execPath, [entry, ...args], {
+            stdio: "inherit",
+            windowsHide: true,
+        });
+        const interrupt = () => {
+            child.kill("SIGINT");
+        };
+        const terminate = () => {
+            child.kill("SIGTERM");
+        };
+        process.once("SIGINT", interrupt);
+        process.once("SIGTERM", terminate);
+        const cleanup = () => {
+            process.off("SIGINT", interrupt);
+            process.off("SIGTERM", terminate);
+        };
+        child.once("error", () => {
+            cleanup();
+            resolve(undefined);
+        });
+        child.once("close", (code) => {
+            cleanup();
+            resolve(code ?? 1);
+        });
+    });
+}

package/dist/updater/install-flow.js

@@ -0,0 +1,26 @@
+export async function runUpdateFlow(plan, deps) {
+    const entry = await deps.install();
+    // npm or package verification failures leave the currently serving app entirely alone.
+    await deps.handoff();
+    let backedUp = false;
+    try {
+        await deps.backup();
+        backedUp = true;
+        await deps.start(entry);
+        await deps.healthy(plan.version);
+        await deps.activate();
+    }
+    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.");
+    }
+    // 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.
+    await deps.release();
+    deps.report(`Slopify ${plan.version} started successfully.`);
+}

package/dist/updater/install.js

@@ -0,0 +1,50 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { updatePlanSchema } from "./plan.js";
+export async function launchUpdate(worker, plan, handoff) {
+    updatePlanSchema.parse(plan);
+    const directory = join(plan.dataDir, "updates");
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    const planPath = join(directory, `plan-${randomUUID()}.json`);
+    await writeFile(planPath, JSON.stringify(plan), { mode: 0o600 });
+    const child = spawn(process.execPath, [worker, planPath], {
+        cwd: plan.cwd,
+        detached: true,
+        windowsHide: true,
+        stdio: ["ignore", "ignore", "ignore", "ipc"],
+    });
+    try {
+        await new Promise((resolve, reject) => {
+            let restarting = false;
+            const send = (type) => {
+                if (!child.connected) {
+                    reject(new Error("The update worker disconnected."));
+                    return;
+                }
+                child.send({ type }, (error) => {
+                    if (error !== null)
+                        reject(new Error("The update handoff failed."));
+                });
+            };
+            child.once("error", () => reject(new Error("The update worker could not start.")));
+            child.once("exit", (code) => code === 0 ? resolve() : reject(new Error("The update worker could not finish.")));
+            child.on("message", (message) => {
+                if (typeof message !== "object" || message === null || !("type" in message))
+                    return;
+                if (message.type === "installed" && !restarting) {
+                    restarting = true;
+                    void handoff().then(() => send("handoff"), () => {
+                        send("abort");
+                        reject(new Error("Slopify could not release its server for the update."));
+                    });
+                }
+            });
+        });
+    }
+    finally {
+        child.unref();
+        await rm(planPath, { force: true });
+    }
+}

package/dist/updater/model.js

@@ -0,0 +1,24 @@
+export const updatePackage = "@gentbajko/slopify";
+export const npmRegistry = "https://registry.npmjs.org/";
+const stableVersion = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
+export function isStableVersion(value) {
+    return value.length <= 50 && stableVersion.test(value);
+}
+export function newerVersion(candidate, current) {
+    if (!isStableVersion(candidate) || !isStableVersion(current))
+        return false;
+    const left = candidate.split(".").map(BigInt);
+    const right = current.split(".").map(BigInt);
+    for (let index = 0; index < 3; index++) {
+        const a = left[index];
+        const b = right[index];
+        if (a === undefined || b === undefined)
+            return false;
+        if (a !== b)
+            return a > b;
+    }
+    return false;
+}
+export function isUpdateToken(value) {
+    return /^[a-f0-9]{64}$/.test(value);
+}