@gentbajko/slopify 0.8.4 → 1.0.0

package/dist/edge/http/revision-files.js

@@ -0,0 +1,84 @@
+import { createReadStream } from "node:fs";
+import { dirname } from "node:path";
+import { Readable } from "node:stream";
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+import { findRevisionDownload, revisionImagesZip } from "../../slices/revisions/downloads.js";
+import { onInvalid, problem, titleOf } from "./problem.js";
+const id = z
+    .string()
+    .min(1)
+    .max(64)
+    .regex(/^[0-9A-Za-z_-]+$/);
+const revisionParam = z.object({ projectId: id, revisionId: id });
+const recordParam = revisionParam.extend({ recordId: id });
+const folderParam = z.object({ id, revisionId: id, recordId: id });
+export function revisionFileRoutes(deps) {
+    return new Hono()
+        .get("/files/:projectId/revisions/:revisionId/images.zip", zValidator("param", revisionParam, onInvalid), (c) => {
+        const { projectId, revisionId } = c.req.valid("param");
+        const result = revisionImagesZip(deps, projectId, revisionId);
+        if (!result.ok)
+            return unavailable(c, result.reason);
+        return c.body(result.bytes, 200, {
+            "content-type": "application/zip",
+            "content-length": String(result.bytes.byteLength),
+            "content-disposition": `attachment; filename="${result.filename}"`,
+        });
+    })
+        .get("/files/:projectId/revisions/:revisionId/:recordId", zValidator("param", recordParam, onInvalid), (c) => {
+        const { projectId, revisionId, recordId } = c.req.valid("param");
+        const result = findRevisionDownload(deps, projectId, revisionId, recordId);
+        if (!result.ok)
+            return unavailable(c, result.reason);
+        const value = result.download;
+        return c.body(Readable.toWeb(createReadStream(value.path)), 200, {
+            "content-type": value.contentType,
+            "content-length": String(value.bytes),
+            "content-disposition": `attachment; filename="${value.filename}"`,
+        });
+    });
+}
+export function revisionFolderRoutes(deps) {
+    return new Hono().post("/:id/revisions/:revisionId/:recordId/open-folder", zValidator("param", folderParam, onInvalid), 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: "Open folders from Slopify itself.",
+            });
+        const { id: projectId, revisionId, recordId } = c.req.valid("param");
+        const result = findRevisionDownload(deps, projectId, revisionId, recordId);
+        if (!result.ok)
+            return unavailable(c, result.reason);
+        try {
+            if (deps.openFolder === undefined)
+                throw new Error("No folder opener configured");
+            await deps.openFolder(dirname(result.download.path));
+            return c.json({ opened: true });
+        }
+        catch {
+            deps.log.write("warn", "project.open-folder", {
+                projectId,
+                detail: "The file manager could not be opened for a retained file.",
+            });
+            return problem(c, {
+                status: 503,
+                title: titleOf(503),
+                detail: "Could not open the file manager on the machine running Slopify. Make sure a desktop session is available.",
+            });
+        }
+    });
+}
+function unavailable(c, reason) {
+    return problem(c, {
+        status: 404,
+        title: titleOf(404),
+        detail: reason === "missing-file"
+            ? "This retained file is no longer on disk. Review the affected rebuild to recreate it."
+            : "The retained file is unavailable.",
+        extensions: { reason },
+    });
+}

package/dist/edge/http/revisions.js

@@ -0,0 +1,103 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+import { projectExists } from "../../slices/admission/repo.js";
+import { previewRebuildSchema, startRebuildSchema } from "../../slices/rebuild/model.js";
+import { previewRebuild, startRebuild } from "../../slices/rebuild/service.js";
+import { ensureBaseline, restoreRevision, saveRevision } from "../../slices/revisions/index.js";
+import { currentRevisionId, listRevisionHistory } from "../../slices/revisions/repo.js";
+import { restoreRevisionSchema, saveRevisionSchema } from "../../slices/revisions/schema.js";
+import { getRevisionView } from "../../slices/revisions/view.js";
+import { onInvalid, problem, titleOf } from "./problem.js";
+const id = z
+    .string()
+    .min(1)
+    .max(64)
+    .regex(/^[0-9A-Za-z_-]+$/);
+const projectParam = z.object({ id });
+const revisionParam = projectParam.extend({ revisionId: id });
+const saveBody = saveRevisionSchema.extend({ idempotencyKey: z.uuid() });
+const restoreBody = restoreRevisionSchema.extend({ idempotencyKey: z.uuid() });
+const statuses = {
+    "no-project": 404,
+    "no-revision": 404,
+    conflict: 409,
+    "idempotency-conflict": 409,
+    "invalid-edit": 400,
+    "stale-preview": 409,
+    "invalid-selection": 400,
+    "review-required": 409,
+    "cost-ack-required": 409,
+    readiness: 409,
+};
+function refused(c, deps, projectId, value) {
+    const status = statuses[value.reason];
+    return problem(c, {
+        status,
+        title: titleOf(status),
+        detail: value.reason.replaceAll("-", " "),
+        extensions: {
+            reason: value.reason,
+            currentRevisionId: currentRevisionId(deps.db, projectId) ?? null,
+            fields: value.fields ?? [],
+        },
+    });
+}
+function unavailable(c) {
+    return problem(c, {
+        status: 503,
+        title: titleOf(503),
+        detail: "Rebuild services are unavailable.",
+    });
+}
+export function revisionRoutes(deps) {
+    return new Hono()
+        .post("/:id/revisions/prepare", zValidator("param", projectParam, onInvalid), async (c) => {
+        const projectId = c.req.valid("param").id;
+        const result = await ensureBaseline(deps, projectId);
+        return result.ok ? c.json(result) : refused(c, deps, projectId, result);
+    })
+        .get("/:id/revisions", zValidator("param", projectParam, onInvalid), (c) => {
+        const projectId = c.req.valid("param").id;
+        return projectExists(deps.db, projectId)
+            ? c.json({ revisions: listRevisionHistory(deps.db, projectId) })
+            : refused(c, deps, projectId, { reason: "no-project" });
+    })
+        .get("/:id/revisions/:revisionId", zValidator("param", revisionParam, onInvalid), (c) => {
+        const { id: projectId, revisionId } = c.req.valid("param");
+        const view = getRevisionView(deps, projectId, revisionId);
+        return view === undefined
+            ? refused(c, deps, projectId, { reason: "no-revision" })
+            : c.json({ view });
+    })
+        .post("/:id/revisions", zValidator("param", projectParam, onInvalid), zValidator("json", saveBody, onInvalid), async (c) => {
+        const projectId = c.req.valid("param").id;
+        const result = await saveRevision(deps, { projectId, ...c.req.valid("json") });
+        if (!result.ok)
+            return refused(c, deps, projectId, result);
+        deps.hub.emit(projectId, { type: "project.updated", projectId });
+        return c.json(result);
+    })
+        .post("/:id/revisions/restore", zValidator("param", projectParam, onInvalid), zValidator("json", restoreBody, onInvalid), async (c) => {
+        const projectId = c.req.valid("param").id;
+        const result = await restoreRevision(deps, { projectId, ...c.req.valid("json") });
+        if (!result.ok)
+            return refused(c, deps, projectId, result);
+        deps.hub.emit(projectId, { type: "project.updated", projectId });
+        return c.json(result);
+    })
+        .post("/:id/rebuild/preview", zValidator("param", projectParam, onInvalid), zValidator("json", previewRebuildSchema, onInvalid), async (c) => {
+        if (deps.rebuild === undefined)
+            return unavailable(c);
+        const projectId = c.req.valid("param").id;
+        const result = await previewRebuild(deps.rebuild, { projectId, ...c.req.valid("json") });
+        return result.ok ? c.json(result) : refused(c, deps, projectId, result);
+    })
+        .post("/:id/rebuild", zValidator("param", projectParam, onInvalid), zValidator("json", startRebuildSchema, onInvalid), async (c) => {
+        if (deps.rebuild === undefined)
+            return unavailable(c);
+        const projectId = c.req.valid("param").id;
+        const result = await startRebuild(deps.rebuild, { projectId, ...c.req.valid("json") });
+        return result.ok ? c.json(result, 202) : refused(c, deps, projectId, result);
+    });
+}

package/dist/edge/http/schedules.js

@@ -0,0 +1,100 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { HTTPException } from "hono/http-exception";
+import { z } from "zod";
+import { scheduleCreateSchema, scheduleRunSchema, scheduleSummarySchema, scheduleUpdateSchema, } from "../../slices/schedules/schema.js";
+import { cancelSchedule, createSchedule, deleteSchedule, listScheduleRuns, listSchedules, pauseSchedule, resumeSchedule, updateSchedule, } from "../../slices/schedules/service.js";
+import { onInvalid, problem, titleOf } from "./problem.js";
+const id = z.object({ id: z.uuid() });
+function refused(c, result) {
+    const status = ["not-found", "missing-template"].includes(result.reason)
+        ? 404
+        : ["conflict", "cancel-required", "spend-limit", "unsupported-media"].includes(result.reason)
+            ? 409
+            : 400;
+    const detail = {
+        "invalid-input": "Check the schedule fields and try again.",
+        "not-found": "The schedule was not found.",
+        conflict: "The schedule changed elsewhere. Reload it before trying again.",
+        "cancel-required": "Cancel this schedule before deleting it. Completed schedules can be deleted directly.",
+        "missing-template": "The selected template version is no longer available.",
+        "unsupported-media": "This template contains provided media and cannot run unattended.",
+        "not-due": "Choose a future one-off time.",
+        "spend-limit": "The estimate exceeds the schedule spend limit or contains unknown pricing.",
+        readiness: "Provider or local readiness checks refused this scheduled run.",
+    };
+    return problem(c, {
+        status,
+        title: titleOf(status),
+        detail: detail[result.reason],
+        extensions: { reason: result.reason },
+    });
+}
+export function scheduleRoutes(deps) {
+    return routes(deps);
+}
+function routes(deps) {
+    const service = () => {
+        if (deps === undefined)
+            throw new HTTPException(404);
+        return deps;
+    };
+    return new Hono()
+        .get("/", (c) => c.json({
+        schedules: listSchedules(service()).map((schedule) => scheduleSummarySchema.parse(schedule)),
+    }))
+        .post("/", zValidator("json", scheduleCreateSchema, onInvalid), (c) => {
+        const result = createSchedule(service(), c.req.valid("json"));
+        return result.ok
+            ? c.json(scheduleSummarySchema.parse(result.value), 201)
+            : refused(c, result);
+    })
+        .get("/:id", zValidator("param", id, onInvalid), (c) => {
+        const input = c.req.valid("param");
+        const schedule = listSchedules(service()).find((item) => item.id === input.id);
+        if (!schedule)
+            return refused(c, { ok: false, reason: "not-found" });
+        const runs = listScheduleRuns(service(), input.id);
+        return runs.ok
+            ? c.json({
+                schedule: scheduleSummarySchema.parse(schedule),
+                runs: runs.value.map((run) => scheduleRunSchema.parse(run)),
+            })
+            : refused(c, runs);
+    })
+        .put("/:id", zValidator("param", id, onInvalid), zValidator("json", scheduleUpdateSchema.unwrap().omit({ id: true }), onInvalid), (c) => {
+        const result = updateSchedule(service(), {
+            ...c.req.valid("json"),
+            id: c.req.valid("param").id,
+        });
+        return result.ok ? c.json(scheduleSummarySchema.parse(result.value)) : refused(c, result);
+    })
+        .post("/:id/pause", zValidator("param", id, onInvalid), zValidator("json", z.object({ baseVersion: z.number().int().positive() }).strict(), onInvalid), (c) => {
+        const result = pauseSchedule(service(), {
+            ...c.req.valid("json"),
+            id: c.req.valid("param").id,
+        });
+        return result.ok ? c.json(scheduleSummarySchema.parse(result.value)) : refused(c, result);
+    })
+        .post("/:id/resume", zValidator("param", id, onInvalid), zValidator("json", z.object({ baseVersion: z.number().int().positive() }).strict(), onInvalid), (c) => {
+        const result = resumeSchedule(service(), {
+            ...c.req.valid("json"),
+            id: c.req.valid("param").id,
+        });
+        return result.ok ? c.json(scheduleSummarySchema.parse(result.value)) : refused(c, result);
+    })
+        .post("/:id/cancel", zValidator("param", id, onInvalid), zValidator("json", z.object({ baseVersion: z.number().int().positive() }).strict(), onInvalid), (c) => {
+        const result = cancelSchedule(service(), {
+            ...c.req.valid("json"),
+            id: c.req.valid("param").id,
+        });
+        return result.ok ? c.json(scheduleSummarySchema.parse(result.value)) : refused(c, result);
+    })
+        .delete("/:id", zValidator("param", id, onInvalid), zValidator("json", z.object({ baseVersion: z.number().int().positive() }).strict(), onInvalid), (c) => {
+        const result = deleteSchedule(service(), {
+            ...c.req.valid("json"),
+            id: c.req.valid("param").id,
+        });
+        return result.ok ? c.json(result.value) : refused(c, result);
+    });
+}

package/dist/edge/http/staging.js

@@ -1,11 +1,10 @@
-import { Readable } from "node:stream";
-import { Busboy } from "@fastify/busboy";
 import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
 import { z } from "zod";
 import { uploadableStageKinds } from "../../slices/storage/model.js";
 import { stagedFiles } from "../../slices/storage/repo.js";
 import { discardStagedFile, stageUpload } from "../../slices/storage/staging.js";
+import { readMultipart } from "./multipart.js";
 import { onInvalid, problem, titleOf } from "./problem.js";
 const kindParam = z.object({ kind: z.enum(uploadableStageKinds) });
 const idParam = z.object({ id: z.string().min(1).max(64) });
@@ -26,23 +25,11 @@ export function stagingRoutes(deps) {
     return new Hono()
         .get("/", (c) => c.json({ files: stagedFiles(deps.db) }))
         .post("/:kind", zValidator("param", kindParam, onInvalid), async (c) => {
-        const contentType = c.req.header("content-type");
-        if (contentType === undefined || !contentType.startsWith("multipart/form-data")) {
-            return problem(c, {
-                status: 415,
-                title: titleOf(415),
-                detail: "An upload is sent as multipart/form-data with the file in one part.",
-            });
-        }
-        const body = c.req.raw.body;
-        if (body === null) {
-            return problem(c, {
-                status: 400,
-                title: titleOf(400),
-                detail: "The request carried no body.",
-            });
-        }
-        const result = await readUpload(storage, c.req.valid("param").kind, contentType, body);
+        const result = await readMultipart(c.req.raw, (content, originalFilename) => stageUpload(storage, {
+            stageKind: c.req.valid("param").kind,
+            originalFilename,
+            content,
+        }));
         if (result === undefined) {
             return problem(c, {
                 status: 400,
@@ -59,44 +46,16 @@ export function stagingRoutes(deps) {
         const result = discardStagedFile(storage, c.req.valid("param").id);
         if (!result.ok) {
             return problem(c, {
-                status: 404,
-                title: titleOf(404),
-                detail: "No staged file has that id.",
+                status: result.reason === "in-use" ? 409 : 404,
+                title: titleOf(result.reason === "in-use" ? 409 : 404),
+                detail: result.reason === "in-use"
+                    ? "This file is used by a saved draft."
+                    : "No staged file has that id.",
             });
         }
         return c.body(null, 204);
     });
 }
-// The bytes go from the socket to the parser to the disk. Nothing collects them: the
-// platform's own formData() materialises a whole part in memory first, which an
-// uncapped audio or video upload cannot afford.
-function readUpload(storage, stageKind, contentType, body) {
-    return new Promise((resolve, reject) => {
-        const parser = new Busboy({
-            headers: { "content-type": contentType },
-            limits: { files: 1, fields: 8 },
-            // The parser hands the name through untouched: silently renaming a file the user
-            // picked would record a name nobody chose, so the slice rejects instead.
-            preservePath: true,
-        });
-        let started = false;
-        parser.on("file", (_field, stream, filename) => {
-            started = true;
-            stageUpload(storage, {
-                stageKind,
-                originalFilename: typeof filename === "string" ? filename : "",
-                content: stream,
-            }).then(resolve, reject);
-        });
-        parser.on("error", reject);
-        parser.on("finish", () => {
-            if (!started) {
-                resolve(undefined);
-            }
-        });
-        Readable.fromWeb(body).pipe(parser);
-    });
-}
 function detailOf(reason) {
     return reason === "empty-file"
         ? "The uploaded file is empty."

package/dist/edge/http/storage.js

@@ -0,0 +1,110 @@
+import { Hono } from "hono";
+import { exportPortable, importPortable, portableMaxArchiveBytes, storageUsage, } from "../../slices/storage/portable.js";
+import { reconcileStorage } from "../../slices/storage/reconcile.js";
+import { problem, titleOf } from "./problem.js";
+export function storageRoutes(deps) {
+    return new Hono()
+        .get("/", (c) => c.json(storageUsage({ db: deps.db, paths: deps.paths })))
+        .get("/export", (c) => {
+        try {
+            const bytes = exportPortable({
+                db: deps.db,
+                paths: deps.paths,
+                ids: deps.ids,
+                now: () => deps.clock.now().toISOString(),
+            });
+            return c.body(bytes, 200, {
+                "content-type": "application/zip",
+                "content-length": String(bytes.byteLength),
+                "content-disposition": 'attachment; filename="slopify-backup.zip"',
+            });
+        }
+        catch {
+            return problem(c, {
+                status: 500,
+                title: titleOf(500),
+                detail: "The backup could not be created.",
+            });
+        }
+    })
+        .put("/import", async (c) => {
+        const contentType = c.req.header("content-type") ?? "";
+        if (!contentType.includes("application/zip"))
+            return problem(c, {
+                status: 415,
+                title: titleOf(415),
+                detail: "Upload a Slopify backup ZIP.",
+            });
+        const upload = await readPortableUpload(c.req.raw);
+        if (!upload.ok)
+            return problem(c, {
+                status: 413,
+                title: titleOf(413),
+                detail: "The backup must be between 1 byte and 100 MB.",
+            });
+        try {
+            const imported = importPortable({
+                db: deps.db,
+                paths: deps.paths,
+                ids: deps.ids,
+                now: () => deps.clock.now().toISOString(),
+            }, upload.bytes);
+            return c.json(imported);
+        }
+        catch {
+            return problem(c, {
+                status: 400,
+                title: titleOf(400),
+                detail: "The backup is invalid or incomplete.",
+            });
+        }
+    })
+        .post("/cleanup", (c) => c.json(reconcileStorage(deps.db, deps.paths)));
+}
+async function readPortableUpload(request) {
+    const declared = request.headers.get("content-length");
+    if (declared !== null && /^\d+$/.test(declared) && Number(declared) > portableMaxArchiveBytes) {
+        try {
+            await request.body?.cancel();
+        }
+        catch {
+            // The request is already rejected; cancellation only releases transport resources sooner.
+        }
+        return { ok: false };
+    }
+    if (request.body === null)
+        return { ok: false };
+    const reader = request.body.getReader();
+    const chunks = [];
+    let total = 0;
+    try {
+        while (true) {
+            const next = await reader.read();
+            if (next.done)
+                break;
+            if (next.value.byteLength > portableMaxArchiveBytes - total) {
+                try {
+                    await reader.cancel();
+                }
+                catch {
+                    // The response is already decided; an upload transport failing cancellation is harmless.
+                }
+                return { ok: false };
+            }
+            total += next.value.byteLength;
+            chunks.push(next.value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    if (total === 0)
+        return { ok: false };
+    const bytes = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return { ok: true, bytes };
+}

package/dist/edge/http/subtitles.js

@@ -1,13 +1,6 @@
 import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
 import { z } from "zod";
-import { transact } from "../../kernel/db/tx.js";
-import { derive } from "../../kernel/runner/graph.js";
-import { projectById, resetStage, stagesOf, updateProjectConfig, } from "../../slices/admission/repo.js";
-import { withProjectControl } from "../../slices/control/lock.js";
-import { resolveFont } from "../../slices/fonts/index.js";
-import { outputsOf } from "../../slices/storage/repo.js";
-import { subtitleConfigSchema } from "../../slices/subtitles/model.js";
 import { onInvalid, problem, titleOf } from "./problem.js";
 const idParam = z.object({
     id: z
@@ -16,77 +9,14 @@ const idParam = z.object({
         .max(64)
         .regex(/^[0-9A-Za-z_-]+$/),
 });
-export function subtitleRoutes(deps) {
-    return new Hono().patch("/:id/subtitles", zValidator("param", idParam, onInvalid), zValidator("json", subtitleConfigSchema, onInvalid), async (c) => {
-        const { id } = c.req.valid("param");
-        return withProjectControl(deps.db, id, async () => {
-            const project = projectById(deps.db, id);
-            if (project === undefined)
-                return problem(c, {
-                    status: 404,
-                    title: titleOf(404),
-                    detail: "No project has that id.",
-                });
-            const stages = stagesOf(deps.db, id);
-            if (stages.some((stage) => stage.state === "running") || deps.runner.hasInflight?.(id))
-                return problem(c, {
-                    status: 409,
-                    title: titleOf(409),
-                    detail: "Pause the run and wait for its active work to stop before changing subtitles.",
-                });
-            const chosen = c.req.valid("json");
-            if (chosen.mode !== "off" && project.config.sources.audio === "off")
-                return problem(c, {
-                    status: 400,
-                    title: titleOf(400),
-                    detail: "Subtitles need narration audio.",
-                });
-            const subtitles = project.config.sources.video === "off" && chosen.mode === "burn-in"
-                ? { ...chosen, mode: "files" }
-                : chosen;
-            if (subtitles.mode !== "off" && subtitles.fontId !== project.config.subtitles?.fontId) {
-                try {
-                    await resolveFont(deps.paths, subtitles.fontId);
-                }
-                catch {
-                    return problem(c, {
-                        status: 400,
-                        title: titleOf(400),
-                        detail: "That font is no longer available. Choose another font or upload it again.",
-                    });
-                }
-            }
-            // Font discovery awaits filesystem work; a pending runner may have claimed a
-            // stage during that time. Recheck synchronously immediately before the write.
-            if (stagesOf(deps.db, id).some((stage) => stage.state === "running") ||
-                deps.runner.hasInflight?.(id)) {
-                return problem(c, {
-                    status: 409,
-                    title: titleOf(409),
-                    detail: "Pause the run before changing subtitles.",
-                });
-            }
-            const video = stages.find((stage) => stage.kind === "video");
-            transact(deps.db, () => {
-                updateProjectConfig(deps.db, id, { ...project.config, subtitles }, deps.clock.now().toISOString());
-                // Only the local final export is invalidated. Existing provider outputs and
-                // the last finished export remain intact until its replacement succeeds.
-                if (video !== undefined &&
-                    (project.config.sources.audio !== "off" || project.config.sources.video !== "off"))
-                    resetStage(deps.db, video.id);
-            });
-            deps.hub.emit(id, { type: "project.updated", projectId: id });
-            if (project.paused !== true)
-                deps.runner.tick(id);
-            const current = stagesOf(deps.db, id);
-            return c.json({
-                project: {
-                    ...projectById(deps.db, id),
-                    status: derive(current, project.paused === true),
-                },
-                stages: current,
-                outputs: outputsOf(deps.db, id),
-            });
-        });
+export function subtitleRoutes(_deps) {
+    return new Hono().patch("/:id/subtitles", zValidator("param", idParam, 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/tutorial.js

@@ -0,0 +1,26 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { readTutorial, resetTutorial, saveTutorial, tutorialWriteSchema, } from "../../slices/settings/tutorial.js";
+import { onInvalid, problem, titleOf } from "./problem.js";
+// Preserve Hono's inferred route types for the web client.
+export function tutorialRoutes(deps) {
+    return new Hono()
+        .get("/", (c) => c.json(readTutorial(deps.db)))
+        .put("/", zValidator("json", tutorialWriteSchema, onInvalid), (c) => {
+        const result = saveTutorial(deps.db, c.req.valid("json"));
+        if (!result.ok)
+            return problem(c, {
+                status: 409,
+                title: titleOf(409),
+                detail: result.reason === "unreadable"
+                    ? "Saved tutorial progress cannot be read. Choose Restart tutorial to reset it."
+                    : "Tutorial progress changed. Reload the saved progress before trying again.",
+                extensions: { reason: result.reason },
+            });
+        return c.json(result.value);
+    })
+        .delete("/", (c) => {
+        resetTutorial(deps.db);
+        return c.body(null, 204);
+    });
+}

package/dist/edge/signal-shutdown.js

@@ -0,0 +1,23 @@
+export function installSignalShutdown(deps) {
+    let stopping;
+    let forced = false;
+    const shutdown = () => {
+        // A second explicit signal is the operator's escape hatch if an external resource
+        // ignores every graceful cancellation path.
+        if (stopping !== undefined) {
+            forced = true;
+            deps.exit(1);
+            return;
+        }
+        stopping = Promise.resolve().then(deps.stop);
+        void stopping.then(() => {
+            if (!forced)
+                deps.exit(0);
+        }, () => {
+            if (!forced)
+                deps.exit(1);
+        });
+    };
+    deps.on("SIGINT", shutdown);
+    deps.on("SIGTERM", shutdown);
+}