@gentbajko/slopify 0.8.3 → 1.0.0

package/dist/edge/http/project-templates.js

@@ -0,0 +1,74 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { HTTPException } from "hono/http-exception";
+import { z } from "zod";
+import { createTemplateFromProject, templateFromProjectSchema, } from "../../slices/project-templates/from-project.js";
+import { templateCreateSchema, templateDeleteSchema, templateInstantiateSchema, templateUpdateSchema, } from "../../slices/project-templates/schema.js";
+import { createTemplate, deleteTemplate, instantiateTemplate, listTemplates, readTemplate, updateTemplate, } from "../../slices/project-templates/service.js";
+import { onInvalid, problem, titleOf } from "./problem.js";
+const param = z.object({ id: z.uuid() });
+function refused(c, result) {
+    const status = result.reason === "not-found"
+        ? 404
+        : ["conflict", "referenced-by-schedule"].includes(result.reason)
+            ? 409
+            : 400;
+    return problem(c, {
+        status,
+        title: titleOf(status),
+        detail: result.reason === "referenced-by-schedule"
+            ? "Cancel and delete the schedules using this template before deleting it. Their run history will be retained."
+            : result.reason === "missing-prompt"
+                ? "A selected prompt or entry is unavailable. Choose another before saving the template."
+                : "Reload the template and check its setup before trying again.",
+        extensions: { reason: result.reason },
+    });
+}
+export function projectTemplateRoutes(deps) {
+    return routes(deps);
+}
+function routes(deps) {
+    const service = () => {
+        if (!deps)
+            throw new HTTPException(404);
+        return deps;
+    };
+    return new Hono()
+        .get("/", (c) => c.json({ templates: listTemplates(service()) }))
+        .post("/from-project/:projectId", zValidator("param", templateFromProjectSchema.unwrap().pick({ projectId: true }), onInvalid), zValidator("json", templateFromProjectSchema.unwrap().omit({ projectId: true }), onInvalid), (c) => {
+        const result = createTemplateFromProject(service(), {
+            ...c.req.valid("json"),
+            projectId: c.req.valid("param").projectId,
+        });
+        return result.ok ? c.json(result.value, 201) : refused(c, result);
+    })
+        .post("/", zValidator("json", templateCreateSchema, onInvalid), (c) => {
+        const result = createTemplate(service(), c.req.valid("json"));
+        return result.ok ? c.json(result.value, 201) : refused(c, result);
+    })
+        .get("/:id", zValidator("param", param, onInvalid), zValidator("query", z.object({ version: z.coerce.number().int().positive().optional() }), onInvalid), (c) => {
+        const result = readTemplate(service(), c.req.valid("param").id, c.req.valid("query").version);
+        return result.ok ? c.json(result.value) : refused(c, result);
+    })
+        .put("/:id", zValidator("param", param, onInvalid), zValidator("json", templateUpdateSchema.unwrap().omit({ id: true }), onInvalid), (c) => {
+        const result = updateTemplate(service(), {
+            ...c.req.valid("json"),
+            id: c.req.valid("param").id,
+        });
+        return result.ok ? c.json(result.value) : refused(c, result);
+    })
+        .delete("/:id", zValidator("param", param, onInvalid), zValidator("json", templateDeleteSchema.unwrap().omit({ id: true }), onInvalid), (c) => {
+        const result = deleteTemplate(service(), {
+            ...c.req.valid("json"),
+            id: c.req.valid("param").id,
+        });
+        return result.ok ? c.json(result.value) : refused(c, result);
+    })
+        .post("/:id/instantiate", zValidator("param", param, onInvalid), zValidator("json", templateInstantiateSchema.unwrap().omit({ templateId: true }), onInvalid), (c) => {
+        const result = instantiateTemplate(service(), {
+            ...c.req.valid("json"),
+            templateId: c.req.valid("param").id,
+        });
+        return result.ok ? c.json(result.value, 201) : refused(c, result);
+    });
+}

package/dist/edge/http/projects.js

@@ -9,6 +9,8 @@ import { startRun } from "../../slices/admission/start.js";
 import { withProjectControl } from "../../slices/control/lock.js";
 import { resolveFont } from "../../slices/fonts/index.js";
 import { pickTemplates, renderPicked } from "../../slices/library/slots.js";
+import { adoptBaseline } from "../../slices/revisions/adopt.js";
+import { currentRevisionId } from "../../slices/revisions/repo.js";
 import { deleteProject } from "../../slices/storage/delete-project.js";
 import { outputsOf, stagedFiles } from "../../slices/storage/repo.js";
 import { record } from "../../slices/telemetry/record.js";
@@ -24,6 +26,7 @@ const idParam = z.object({
 // generated from; see stagingRoutes.
 export function projectRoutes(deps) {
     const storage = {
+        catalogue: deps.catalogue,
         db: deps.db,
         paths: deps.paths,
         ids: deps.ids,
@@ -40,13 +43,24 @@ export function projectRoutes(deps) {
         log: deps.log,
         appVersion: deps.version,
     };
-    const storageForDelete = { db: deps.db, paths: deps.paths, log: deps.log };
+    const storageForDelete = {
+        db: deps.db,
+        paths: deps.paths,
+        log: deps.log,
+        hasInflight: deps.runner.hasInflight,
+    };
     const summarise = (project) => ({
         ...project,
         status: derive(stagesOf(deps.db, project.id), project.paused),
     });
     return (new Hono()
         .post("/", zValidator("json", runDraftSchema, onInvalid), async (c) => {
+        if (c.req.valid("json").checkpoints?.length)
+            return problem(c, {
+                status: 409,
+                title: titleOf(409),
+                detail: "Start checkpoint-enabled projects through Play Review.",
+            });
         const requestedSubtitles = c.req.valid("json").subtitles;
         if (requestedSubtitles !== undefined && requestedSubtitles.mode !== "off") {
             try {
@@ -89,7 +103,7 @@ export function projectRoutes(deps) {
         }
         // Rendered from the values admit() has trimmed, so the stored text carries no
         // padding the user did not intend.
-        const { project } = startRun(storage, admitted.draft, renderPicked(picked, admitted.draft.values));
+        const { project } = startRun(storage, admitted.draft, renderPicked(picked, admitted.draft.values), false, Object.fromEntries(picked.bodies.map(({ key, body }) => [key, body])));
         // One event per project created. record() swallows its own
         // failures, so a broken telemetry write cannot cost the user the run.
         record(telemetry, "project.created", {});
@@ -124,7 +138,10 @@ export function projectRoutes(deps) {
                 detail: "No project has that id.",
             });
         }
+        if (deps.catalogue !== undefined)
+            adoptBaseline(deps, project.id);
         return c.json({
+            revisionId: currentRevisionId(deps.db, project.id) ?? null,
             project: summarise(project),
             stages: stagesOf(deps.db, project.id),
             outputs: outputsOf(deps.db, project.id),

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 };
+}