@gentbajko/slopify 0.6.1 → 0.8.0

package/dist/catalog/store.js

@@ -0,0 +1,90 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { parse } from "yaml";
+import { catalogueSchema } from "./schema.js";
+export const catalogueSource = "https://raw.githubusercontent.com/GentBajko/slopify/main/packages/app/src/assets/models.yaml";
+export function parseCatalogue(text) {
+    if (Buffer.byteLength(text) > 1024 * 1024)
+        throw new Error("Model catalogue exceeds 1 MB");
+    return catalogueSchema.parse(parse(text, { maxAliasCount: 20, uniqueKeys: true }));
+}
+export function createCatalogueStore(deps) {
+    const path = join(deps.dataDir, "models.yaml");
+    const bundled = deps.bundled ?? readFileSync(new URL("../assets/models.yaml", import.meta.url), "utf8");
+    let current = parseCatalogue(bundled);
+    mkdirSync(deps.dataDir, { recursive: true, mode: 0o700 });
+    if (!existsSync(path))
+        writeFileSync(path, bundled, { mode: 0o600, flag: "wx" });
+    let stamp = "";
+    let warning = null;
+    let refreshing;
+    function read() {
+        try {
+            const file = statSync(path);
+            const next = `${file.mtimeMs}:${file.size}`;
+            if (next !== stamp) {
+                stamp = next;
+                if (file.size > 1024 * 1024)
+                    throw new Error("Oversized catalogue");
+                current = parseCatalogue(readFileSync(path, "utf8"));
+                warning = null;
+            }
+        }
+        catch {
+            warning =
+                "Your models.yaml is unavailable or invalid. The last valid catalogue is still in use.";
+        }
+        return current;
+    }
+    async function refresh() {
+        const response = await deps.fetch(catalogueSource, {
+            signal: AbortSignal.timeout(15000),
+            redirect: "error",
+        });
+        if (!response.ok)
+            throw new Error(`Catalogue update answered ${response.status}`);
+        if (!response.body)
+            throw new Error("Empty catalogue response");
+        const chunks = [];
+        let size = 0;
+        const reader = response.body.getReader();
+        try {
+            for (;;) {
+                const next = await reader.read();
+                if (next.done)
+                    break;
+                size += next.value.byteLength;
+                if (size > 1024 * 1024)
+                    throw new Error("Catalogue exceeds 1 MB");
+                chunks.push(next.value);
+            }
+        }
+        finally {
+            await reader.cancel().catch(() => { });
+            reader.releaseLock();
+        }
+        const text = Buffer.concat(chunks).toString("utf8");
+        const next = parseCatalogue(text);
+        mkdirSync(deps.dataDir, { recursive: true, mode: 0o700 });
+        // A manual refresh replaces the local catalogue; retain the previous text for recovery.
+        if (existsSync(path))
+            writeFileSync(`${path}.previous`, readFileSync(path), { mode: 0o600 });
+        writeFileSync(`${path}.next`, text, { mode: 0o600 });
+        renameSync(`${path}.next`, path);
+        current = next;
+        stamp = "";
+        warning = null;
+        read();
+    }
+    return {
+        read,
+        models: (provider, family) => read()[family].filter((m) => m.provider === provider && m.enabled && !m.deprecated),
+        status: () => ({ updatedAt: read().updatedAt, path, warning, source: catalogueSource }),
+        refresh: () => {
+            refreshing ??= refresh().finally(() => {
+                refreshing = undefined;
+            });
+            return refreshing;
+        },
+    };
+}

package/dist/catalog/validate.js

@@ -0,0 +1,43 @@
+export function modelFields(draft, catalogue) {
+    if (!catalogue)
+        return [];
+    const fields = [];
+    const needLlm = draft.sources.research === "generate" ||
+        draft.sources.article === "generate" ||
+        draft.sources.thumbnail === "prompt_by_llm" ||
+        draft.intro?.mode === "llm" ||
+        draft.outro?.mode === "llm";
+    const checks = [
+        { field: "llm", family: "llm", choice: draft.llm, needed: needLlm },
+        {
+            field: "audio",
+            family: "tts",
+            choice: draft.audio,
+            needed: draft.sources.audio === "generate",
+        },
+        {
+            field: "images",
+            family: "image",
+            choice: draft.images,
+            needed: draft.sources.images === "generate" ||
+                ["from_prompt", "prompt_by_llm"].includes(draft.sources.thumbnail),
+        },
+    ];
+    for (const { field, family, choice, needed } of checks) {
+        if (!needed || !choice)
+            continue;
+        const model = catalogue.models(choice.provider, family).find((m) => m.id === choice.model);
+        if (!model)
+            fields.push({ field, message: "Choose an enabled model from the current catalogue." });
+        else if ("llm" in model && choice.thinking && !model.llm.thinking?.[choice.thinking])
+            fields.push({ field, message: "Choose a supported thinking setting for this model." });
+        else if ("llm" in model && draft.sources.research === "generate" && !model.llm.webSearch)
+            fields.push({
+                field,
+                message: "This model cannot perform web research. Choose another or turn Research off.",
+            });
+        else if ("image" in model && !model.image.aspectRatios.includes(draft.format))
+            fields.push({ field, message: "This image model does not support the selected shape." });
+    }
+    return fields;
+}

package/dist/edge/cli.js

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
 import { parseArgs } from "node:util";
 import { configFrom } from "../kernel/config/index.js";
+import { readVersion } from "../kernel/version.js";
 import { boot } from "../main.js";
+import { forwardManagedUpdate } from "../updater/forward.js";
 import { openBrowser } from "./open-browser.js";
 const { values } = parseArgs({
     options: {
@@ -13,6 +15,9 @@ const { values } = parseArgs({
 });
 try {
     const config = configFrom(values, process.env);
+    const forwarded = await forwardManagedUpdate(config.dataDir, readVersion(), process.argv.slice(2));
+    if (forwarded !== undefined)
+        process.exit(forwarded);
     const { paths, url, stop } = await boot(config);
     console.log(`Slopify is running at ${url}`);
     console.log(`Slopify data directory: ${paths.dataDir}`);

package/dist/edge/events/hub.js

@@ -1,4 +1,6 @@
+import { createPreviewCache } from "./preview-cache.js";
 export function createHub(deps) {
+    const previews = createPreviewCache();
     const projects = new Map();
     const globals = new Set();
     // The tally a page needs before anything else happens. The runner emits it when it
@@ -43,11 +45,15 @@ export function createHub(deps) {
         subscribe: (projectId, stream, signal) => {
             const set = projects.get(projectId) ?? new Set();
             projects.set(projectId, set);
-            return join(set, stream, signal, () => {
+            const subscriber = join(set, stream, signal, () => {
                 if (set.size === 0) {
                     projects.delete(projectId);
                 }
-            }).done;
+            });
+            if (set.has(subscriber))
+                for (const event of previews.snapshot(projectId))
+                    send(subscriber, event);
+            return subscriber.done;
         },
         subscribeGlobal: (stream, signal) => {
             const subscriber = join(globals, stream, signal, () => { });
@@ -57,6 +63,7 @@ export function createHub(deps) {
             return subscriber.done;
         },
         emit: (projectId, event) => {
+            previews.observe(event);
             for (const subscriber of projects.get(projectId) ?? []) {
                 send(subscriber, event);
             }

package/dist/edge/events/preview-cache.js

@@ -0,0 +1,40 @@
+// Preview memory is bounded independently from durable outputs. A subscriber joining
+// mid-call receives only visible response text, never prompts or provider reasoning.
+export function createPreviewCache() {
+    const projects = new Map();
+    return {
+        observe: (event) => {
+            if (event.type === "stage.state") {
+                const calls = projects.get(event.projectId);
+                if (calls) {
+                    for (const [id, call] of calls)
+                        if (call.stage === event.stage)
+                            calls.delete(id);
+                    if (calls.size === 0)
+                        projects.delete(event.projectId);
+                }
+                return;
+            }
+            if (event.type !== "llm.preview")
+                return;
+            const calls = projects.get(event.projectId) ?? new Map();
+            const prior = calls.get(event.callId);
+            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 });
+            while (calls.size > 8) {
+                const id = calls.keys().next().value;
+                if (id !== undefined)
+                    calls.delete(id);
+            }
+            projects.delete(event.projectId);
+            projects.set(event.projectId, calls);
+            while (projects.size > 16) {
+                const id = projects.keys().next().value;
+                if (id !== undefined)
+                    projects.delete(id);
+            }
+        },
+        snapshot: (projectId) => [...(projects.get(projectId)?.values() ?? [])],
+    };
+}

package/dist/edge/http/actions.js

@@ -9,6 +9,7 @@ import { changeProviders, pauseProject, resumeProject } from "../../slices/contr
 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 { 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";
@@ -79,6 +80,7 @@ export function actionRoutes(deps) {
         runner: deps.runner,
         emit: (projectId, event) => deps.hub.emit(projectId, event),
         providers: () => providerStatuses({ db: deps.db, probe: deps.probe }),
+        allowsCustomModels: deps.catalogue ? () => false : allowsCustomModel,
         modelsFor: deps.modelsFor ?? (() => Promise.reject(new Error("Model catalog unavailable"))),
     };
     const view = (projectId) => {

package/dist/edge/http/app.js

@@ -3,9 +3,11 @@ import { serveStatic } from "@hono/node-server/serve-static";
 import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
 import { actionRoutes } from "./actions.js";
+import { audioPreviewRoutes } from "./audio-preview.js";
 import { entryRoutes } from "./entries.js";
 import { fileRoutes } from "./files.js";
 import { fontsRoutes } from "./fonts.js";
+import { planningRoutes } from "./planning.js";
 import { problem, problemFromError, titleOf } from "./problem.js";
 import { projectRoutes } from "./projects.js";
 import { promptRoutes } from "./prompts.js";
@@ -14,6 +16,7 @@ import { settingsRoutes } from "./settings.js";
 import { stagingRoutes } from "./staging.js";
 import { subtitleRoutes } from "./subtitles.js";
 import { telemetryRoutes } from "./telemetry.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" +
     "Build the SPA with `npm run build` at the repository root.\n";
@@ -25,7 +28,10 @@ function apiRoutes(deps, startedAt) {
         uptimeMs: deps.clock.now().getTime() - startedAt,
     }))
         .route("/staging", stagingRoutes(deps))
+        .route("/projects", planningRoutes(deps))
         .route("/projects", projectRoutes(deps))
+        .route("/projects", audioPreviewRoutes(deps))
+        .route("/update", updateRoutes(deps))
         // The re-run and cancel actions sit on the same prefix as the project itself; they
         // are their own router because they are their own concern.
         .route("/projects", actionRoutes(deps))
@@ -42,8 +48,29 @@ export function createApp(deps) {
     const startedAt = deps.clock.now().getTime();
     const app = new Hono()
         .use("*", async (c, next) => {
-        c.header("X-Slopify-Version", deps.version);
+        // A provisional candidate must not trigger the stale-tab Reload dialog.
+        if (!deps.updater?.locked())
+            c.header("X-Slopify-Version", deps.version);
         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))
+            return next();
+        const release = deps.updater.beginMutation();
+        if (release === undefined)
+            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();
+        }
     })
         .onError((error, c) => problemFromError(c, error, deps))
         .notFound(missing)

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

@@ -0,0 +1,46 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+import { projectTitle } from "../../slices/storage/repo.js";
+import { onInvalid, problem, titleOf } from "./problem.js";
+const projectParam = z.object({
+    projectId: z
+        .string()
+        .min(1)
+        .max(64)
+        .regex(/^[0-9A-Za-z_-]+$/),
+});
+const previewParam = projectParam.extend({ previewId: z.uuid() });
+export function audioPreviewRoutes(deps) {
+    return new Hono()
+        .get("/:projectId/audio-preview", zValidator("param", projectParam, onInvalid), (c) => {
+        const { projectId } = c.req.valid("param");
+        if (projectTitle(deps.db, projectId) === undefined)
+            return missing(c);
+        c.header("Cache-Control", "no-store");
+        return c.json({ previews: deps.audioPreviews?.list(projectId) ?? [] });
+    })
+        .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 stream = deps.audioPreviews?.stream(projectId, previewId, c.req.raw.signal);
+        if (stream === undefined)
+            return missing(c);
+        // A growing MP3 has no final length or seek range. A native audio element
+        // can consume it progressively; late listeners receive the retained prefix.
+        return c.body(stream, 200, {
+            "Content-Type": "audio/mpeg",
+            "Cache-Control": "no-store",
+            "Accept-Ranges": "none",
+            "X-Content-Type-Options": "nosniff",
+        });
+    });
+}
+function missing(c) {
+    return problem(c, {
+        status: 404,
+        title: titleOf(404),
+        detail: "This live audio preview is no longer available. Finished narration is available in the audio outputs.",
+    });
+}

package/dist/edge/http/planning.js

@@ -0,0 +1,101 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+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 { estimateRun } from "../../slices/estimate/index.js";
+import { resolveFont } from "../../slices/fonts/index.js";
+import { pickTemplates, renderPicked } from "../../slices/library/slots.js";
+import { stagedFiles } from "../../slices/storage/repo.js";
+import { onInvalid, problem, titleOf } from "./problem.js";
+const planningBody = z.object({
+    draft: runDraftSchema,
+    expectedWords: z.number().int().min(1).max(100000).default(1500),
+    items: z
+        .array(z
+        .object({
+        title: z.string().trim().min(1).max(200),
+        values: z.record(z.string().max(200), z.string().max(10000)),
+    })
+        .strict())
+        .min(1)
+        .max(50)
+        .optional(),
+});
+const batchBody = planningBody.extend({ requestId: z.uuid() });
+export function planningRoutes(deps) {
+    const prepare = (input) => {
+        const drafts = input.items?.map((item) => ({
+            ...input.draft,
+            title: item.title,
+            values: { ...input.draft.values, ...item.values },
+        })) ?? [input.draft];
+        return drafts.map((draft, index) => {
+            const picked = pickTemplates(deps.db, draft);
+            const admitted = admit({
+                draft: picked.draft,
+                staged: stagedFiles(deps.db),
+                requiredSlots: picked.requiredSlots,
+            });
+            const accepted = admitted.ok ? admitted.draft : picked.draft;
+            const fields = [
+                ...picked.missing,
+                ...(admitted.ok ? [] : admitted.fields),
+                ...modelFields(accepted, deps.catalogue),
+            ].map((f) => ({
+                ...f,
+                message: `${drafts.length > 1 ? `Video ${index + 1}: ` : ""}${f.message}`,
+            }));
+            return { draft: accepted, rendered: renderPicked(picked, accepted.values), fields };
+        });
+    };
+    return new Hono()
+        .get("/queue", (c) => c.json({ queue: queueEntries(deps.db) }))
+        .post("/estimate", zValidator("json", planningBody, onInvalid), (c) => {
+        const input = c.req.valid("json");
+        const runs = prepare(input);
+        const fields = runs.flatMap((r) => r.fields);
+        if (fields.length)
+            return problem(c, {
+                status: 400,
+                title: titleOf(400),
+                detail: "Review the run setup.",
+                extensions: { fields },
+            });
+        return c.json({
+            estimates: runs.map((r) => estimateRun(r.draft, r.rendered, input.expectedWords, deps.catalogue)),
+        });
+    })
+        .post("/batch", zValidator("json", batchBody, onInvalid), async (c) => {
+        const input = c.req.valid("json");
+        if (batchExists(deps.db, input.requestId))
+            return c.json({ queue: queueEntries(deps.db, input.requestId) });
+        const subtitles = input.draft.subtitles;
+        if (subtitles && subtitles.mode !== "off") {
+            try {
+                await resolveFont(deps.paths, subtitles.fontId);
+            }
+            catch {
+                return problem(c, {
+                    status: 400,
+                    title: titleOf(400),
+                    detail: "Choose an available subtitle font before starting.",
+                });
+            }
+        }
+        const runs = prepare(input);
+        const fields = runs.flatMap((r) => r.fields);
+        if (fields.length)
+            return problem(c, {
+                status: 400,
+                title: titleOf(400),
+                detail: "No videos were queued. Review the listed fields.",
+                extensions: { fields },
+            });
+        const queue = enqueueBatch({ ...deps, emit: (event) => deps.hub.emitGlobal(event) }, input.requestId, runs);
+        pumpQueue(deps.db, deps.runner);
+        return c.json({ queue }, 201);
+    });
+}

package/dist/edge/http/projects.js

@@ -1,6 +1,7 @@
 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";
@@ -75,13 +76,14 @@ export function projectRoutes(deps) {
             staged: stagedFiles(deps.db),
             requiredSlots: picked.requiredSlots,
         });
-        if (!admitted.ok || picked.missing.length > 0) {
+        const modelErrors = modelFields(picked.draft, deps.catalogue);
+        if (!admitted.ok || picked.missing.length > 0 || modelErrors.length > 0) {
             return problem(c, {
                 status: 400,
                 title: titleOf(400),
                 detail: "This run cannot start yet; the listed fields need attention.",
                 extensions: {
-                    fields: [...picked.missing, ...(admitted.ok ? [] : admitted.fields)],
+                    fields: [...picked.missing, ...modelErrors, ...(admitted.ok ? [] : admitted.fields)],
                 },
             });
         }

package/dist/edge/http/providers.js

@@ -4,6 +4,7 @@ import { z } from "zod";
 import { cliPathMaxLength, saveCliPath } from "../../slices/settings/cli-paths.js";
 import { keyStatus, removeProviderKey, saveProviderKey } from "../../slices/settings/keys.js";
 import { providerById, providerIds } from "../../slices/settings/model.js";
+import { createModelCatalog } from "../../slices/settings/models.js";
 import { providerStatuses } from "../../slices/settings/readiness.js";
 import { onInvalid, problem, titleOf } from "./problem.js";
 const providerParam = z.object({ id: z.enum(providerIds) });
@@ -17,10 +18,50 @@ const keyBody = z.object({ key: z.string().min(1).max(4096) });
 export function providerRoutes(deps) {
     const keys = { db: deps.db, clock: deps.clock };
     const readiness = { db: deps.db, probe: deps.probe };
+    const catalog = createModelCatalog({
+        load: deps.modelsFor ?? (() => Promise.reject(new Error("Model catalog unavailable"))),
+        fallback: deps.fallbackModelsFor ?? (() => []),
+        now: () => deps.clock.now().getTime(),
+        report: (provider) => deps.log.write("warn", "model-catalog", { detail: `Could not load models for ${provider}` }),
+    });
     return (new Hono()
+        .get("/catalogue", (c) => c.json(deps.catalogue?.status() ?? { warning: "Catalogue unavailable." }))
+        .post("/catalogue/refresh", async (c) => {
+        if (!deps.catalogue)
+            return problem(c, { status: 503, title: titleOf(503), detail: "Catalogue unavailable." });
+        try {
+            await deps.catalogue.refresh();
+        }
+        catch {
+            return problem(c, {
+                status: 502,
+                title: titleOf(502),
+                detail: "Could not update the catalogue. The last valid version remains in use.",
+            });
+        }
+        return c.json(deps.catalogue.status());
+    })
         // What Settings draws its rails from and Play its dropdowns: every provider, with
         // the one fact that decides whether it is selectable.
         .get("/", async (c) => c.json({ providers: await providerStatuses(readiness) }))
+        .get("/:id/models", zValidator("param", providerParam, onInvalid), async (c) => {
+        const { id } = c.req.valid("param");
+        if (deps.catalogue)
+            return c.json({
+                models: deps.catalogue.models(id, providerById(id).family).map((m) => ({
+                    ...m,
+                    ...("llm" in m && m.llm.thinking
+                        ? { thinkingModes: Object.keys(m.llm.thinking) }
+                        : {}),
+                })),
+                allowsCustom: false,
+                notice: "Curated active models from models.yaml. Edit it locally or refresh in Settings.",
+                warning: deps.catalogue.status().warning ?? undefined,
+            });
+        const result = await catalog.get(id, providerById(id).family, c.req.query("refresh") === "1");
+        c.header("Cache-Control", "no-store");
+        return c.json(result);
+    })
         .put("/:id/path", zValidator("param", providerParam, onInvalid), zValidator("json", pathBody, onInvalid), async (c) => {
         const result = await saveCliPath(readiness, c.req.valid("param").id, c.req.valid("json").path);
         if (!result.ok)
@@ -30,6 +71,7 @@ export function providerRoutes(deps) {
                 detail: result.message,
                 extensions: { fields: [{ field: "path", message: result.message }] },
             });
+        catalog.invalidate(c.req.valid("param").id);
         return c.json(result.status);
     })
         .put("/:id/key", zValidator("param", providerParam, onInvalid), zValidator("json", keyBody, onInvalid), (c) => {
@@ -38,6 +80,7 @@ export function providerRoutes(deps) {
         if (!result.ok) {
             return refusal(c, id, result.reason);
         }
+        catalog.invalidate(id);
         // The response says a key is stored and shows the mask, never the value.
         return c.json(keyStatus(keys, id));
     })
@@ -47,6 +90,7 @@ export function providerRoutes(deps) {
         if (!result.ok) {
             return refusal(c, id, result.reason);
         }
+        catalog.invalidate(id);
         return c.body(null, 204);
     }));
 }

package/dist/edge/http/update.js

@@ -0,0 +1,57 @@
+import { Hono } from "hono";
+import { problem, titleOf } from "./problem.js";
+export function updateRoutes(deps) {
+    const unavailable = {
+        currentVersion: deps.version,
+        latestVersion: null,
+        available: false,
+        busy: false,
+        canUpdate: false,
+        status: "idle",
+        blockedReason: "In-app updates are unavailable for this server.",
+    };
+    return new Hono()
+        .get("/ready", (c) => {
+        c.header("Cache-Control", "no-store");
+        if (!deps.updater?.ready(c.req.header("X-Slopify-Update-Token") ?? ""))
+            return problem(c, { status: 403, title: titleOf(403) });
+        return c.json({ status: "ok", version: deps.version });
+    })
+        .post("/activate", async (c) => {
+        c.header("Cache-Control", "no-store");
+        const token = c.req.header("X-Slopify-Update-Token") ?? "";
+        if (!deps.updater?.ready(token))
+            return problem(c, { status: 403, title: titleOf(403) });
+        if (!(await deps.updater.activate(token)))
+            return problem(c, { status: 409, title: titleOf(409) });
+        return c.json({ status: "ok", version: deps.version });
+    })
+        .get("/", async (c) => {
+        c.header("Cache-Control", "no-store");
+        return c.json(deps.updater === undefined
+            ? unavailable
+            : await deps.updater.check(c.req.query("refresh") === "1"));
+    })
+        .post("/", async (c) => {
+        const origin = c.req.header("Origin");
+        if (origin !== undefined && origin !== new URL(c.req.url).origin)
+            return problem(c, {
+                status: 403,
+                title: titleOf(403),
+                detail: "Start updates from the Slopify page on this server.",
+            });
+        if (deps.updater === undefined)
+            return problem(c, { status: 409, title: titleOf(409), detail: unavailable.blockedReason });
+        const result = await deps.updater.start();
+        if (result.ok)
+            return c.json(result.info, 202);
+        const status = result.code ?? 409;
+        return problem(c, {
+            status,
+            title: titleOf(status),
+            detail: result.info.blockedReason ??
+                result.info.error ??
+                "No newer published update is available.",
+        });
+    });
+}

package/dist/edge/update-worker.js

@@ -0,0 +1,44 @@
+import { readFile, rm } from "node:fs/promises";
+import { updatePlanSchema } from "../updater/plan.js";
+import { performUpdate } from "../updater/worker.js";
+const planPath = process.argv[2];
+try {
+    if (planPath === undefined || !process.connected)
+        throw new Error("An update plan and parent process are required.");
+    const plan = updatePlanSchema.parse(JSON.parse(await readFile(planPath, "utf8")));
+    await rm(planPath, { force: true });
+    await performUpdate(plan, () => new Promise((resolve, reject) => {
+        if (!process.connected) {
+            reject(new Error("The update parent disconnected."));
+            return;
+        }
+        const fail = () => {
+            clearTimeout(timer);
+            reject(new Error("The update parent disconnected."));
+        };
+        const timer = setTimeout(() => reject(new Error("The update handoff timed out.")), 60_000);
+        process.once("disconnect", fail);
+        process.once("message", (message) => {
+            clearTimeout(timer);
+            process.off("disconnect", fail);
+            if (typeof message === "object" &&
+                message !== null &&
+                "type" in message &&
+                message.type === "handoff")
+                resolve();
+            else
+                reject(new Error("The update handoff was refused."));
+        });
+        process.send?.({ type: "installed" }, (error) => {
+            if (error !== null)
+                fail();
+        });
+    }));
+    if (process.connected)
+        process.disconnect?.();
+}
+catch {
+    if (process.connected)
+        process.disconnect?.();
+    process.exitCode = 1;
+}