@gentbajko/slopify 0.7.0 → 0.8.1

package/dist/catalog/schema.js

@@ -0,0 +1,91 @@
+import { z } from "zod";
+import { providers } from "../slices/settings/model.js";
+const money = z.number().finite().nonnegative();
+const base = z.object({
+    provider: z.string().regex(/^[a-z0-9-]+$/),
+    id: z.string().min(1).max(200),
+    name: z.string().min(1).max(120),
+    enabled: z.boolean().default(true),
+    deprecated: z.boolean().default(false),
+    source: z.url(),
+    keywords: z.array(z.string().max(60)).default([]),
+    pricing: z
+        .object({
+        inputPerMillionTokens: money.optional(),
+        outputPerMillionTokens: money.optional(),
+        perMillionCharacters: money.optional(),
+        perImage: money.optional(),
+        perMinute: money.optional(),
+        note: z.string().max(1000).optional(),
+    })
+        .strict()
+        .default({}),
+});
+export const llmModelSchema = base
+    .extend({
+    llm: z
+        .object({
+        contextTokens: z.number().int().positive().optional(),
+        maxOutputTokens: z.number().int().positive().optional(),
+        webSearch: z.boolean().default(false),
+        thinking: z
+            .partialRecord(z.enum(["off", "low", "medium", "high", "xhigh"]), z
+            .object({
+            budget: z.number().int().min(-1).optional(),
+            level: z.enum(["minimal", "low", "medium", "high"]).optional(),
+            effort: z.enum(["none", "minimal", "low", "medium", "high", "xhigh"]).optional(),
+        })
+            .strict())
+            .optional(),
+    })
+        .strict(),
+})
+    .strict();
+export const imageModelSchema = base
+    .extend({
+    image: z
+        .object({
+        aspectRatios: z.array(z.enum(["16:9", "9:16"])).min(1),
+        resolution: z.string().max(100).optional(),
+    })
+        .strict(),
+})
+    .strict();
+export const ttsModelSchema = base
+    .extend({
+    tts: z
+        .object({
+        maxCharacters: z.number().int().min(2).max(1000000),
+        streaming: z.boolean(),
+        asyncMaxCharacters: z.number().int().positive().optional(),
+    })
+        .strict(),
+})
+    .strict();
+export const catalogueSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    updatedAt: z.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+    providers: z.record(z.string().regex(/^[a-z0-9-]+$/), z.object({ maxConcurrent: z.number().int().min(1).max(5) }).strict()),
+    llm: z.array(llmModelSchema).max(300),
+    image: z.array(imageModelSchema).max(200),
+    tts: z.array(ttsModelSchema).max(100),
+})
+    .strict()
+    .superRefine((data, ctx) => {
+    const seen = new Set();
+    for (const family of ["llm", "image", "tts"])
+        for (const model of data[family]) {
+            if (!providers.some((p) => p.id === model.provider && p.family === family))
+                ctx.addIssue({ code: "custom", message: `Unknown ${family} provider ${model.provider}` });
+            const key = `${model.provider}:${model.id}`;
+            if (seen.has(key))
+                ctx.addIssue({ code: "custom", message: `Duplicate model ${key}` });
+            seen.add(key);
+            if (!data.providers[model.provider])
+                ctx.addIssue({
+                    code: "custom",
+                    message: `Missing provider limits for ${model.provider}`,
+                });
+        }
+});

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/http/actions.js

@@ -80,7 +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: allowsCustomModel,
+        allowsCustomModels: deps.catalogue ? () => false : allowsCustomModel,
         modelsFor: deps.modelsFor ?? (() => Promise.reject(new Error("Model catalog unavailable"))),
     };
     const view = (projectId) => {

package/dist/edge/http/app.js

@@ -7,6 +7,8 @@ import { audioPreviewRoutes } from "./audio-preview.js";
 import { entryRoutes } from "./entries.js";
 import { fileRoutes } from "./files.js";
 import { fontsRoutes } from "./fonts.js";
+import { openFolderRoutes } from "./open-folder.js";
+import { planningRoutes } from "./planning.js";
 import { problem, problemFromError, titleOf } from "./problem.js";
 import { projectRoutes } from "./projects.js";
 import { promptRoutes } from "./prompts.js";
@@ -27,7 +29,9 @@ function apiRoutes(deps, startedAt) {
         uptimeMs: deps.clock.now().getTime() - startedAt,
     }))
         .route("/staging", stagingRoutes(deps))
+        .route("/projects", planningRoutes(deps))
         .route("/projects", projectRoutes(deps))
+        .route("/projects", openFolderRoutes(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

package/dist/edge/http/open-folder.js

@@ -0,0 +1,61 @@
+import { dirname } from "node:path";
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+import { assetOf, findDownload } from "../../slices/storage/downloads.js";
+import { outputsOf } from "../../slices/storage/repo.js";
+import { onInvalid, problem, titleOf } from "./problem.js";
+export function openFolderRoutes(deps) {
+    return new Hono().post("/:id/open-folder", zValidator("param", z.object({
+        id: z
+            .string()
+            .min(1)
+            .max(64)
+            .regex(/^[0-9A-Za-z_-]+$/),
+    }), onInvalid), zValidator("json", z.object({
+        asset: z
+            .string()
+            .max(64)
+            .regex(/^(?:[a-z0-9-]+|images\.zip)$/),
+    }), 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 } = c.req.valid("param");
+        const { asset } = c.req.valid("json");
+        // The archive is virtual; open the first existing image's folder without building a zip.
+        const assets = asset === "images.zip"
+            ? outputsOf(deps.db, id)
+                .filter((output) => output.role === "image" || output.role === "thumbnail")
+                .map(assetOf)
+            : [asset];
+        const download = assets
+            .map((name) => findDownload(deps, id, name))
+            .find((result) => result.ok);
+        if (download === undefined || !download.ok) {
+            return problem(c, {
+                status: 404,
+                title: titleOf(404),
+                detail: "No saved file was found for this output. Re-run the stage if the file was removed.",
+            });
+        }
+        try {
+            if (deps.openFolder === undefined)
+                throw new Error("No folder opener configured");
+            await deps.openFolder(dirname(download.download.path));
+            return c.json({ opened: true });
+        }
+        catch {
+            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.",
+            });
+        }
+    });
+}

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

@@ -25,11 +25,39 @@ export function providerRoutes(deps) {
         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);

package/dist/edge/open-folder.js

@@ -0,0 +1,25 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { isWsl } from "./open-browser.js";
+const execute = promisify(execFile);
+export function folderCommand(platform, path, wsl = false) {
+    if (platform === "win32" || wsl)
+        return ["explorer.exe", [path]];
+    return [platform === "darwin" ? "open" : "xdg-open", [path]];
+}
+export async function openFolder(path) {
+    const wsl = isWsl(process.platform);
+    const target = wsl
+        ? (await execute("wslpath", ["-w", path], { timeout: 5000 })).stdout.trim()
+        : path;
+    const [command, args] = folderCommand(process.platform, target, wsl);
+    try {
+        await execute(command, args, { timeout: 10000 });
+    }
+    catch (error) {
+        // Explorer commonly reports 1 even when it successfully opens an existing window.
+        if (command === "explorer.exe" && error instanceof Error && "code" in error && error.code === 1)
+            return;
+        throw error;
+    }
+}

package/dist/kernel/db/migrations/0003-batch-queue.sql

@@ -0,0 +1,11 @@
+CREATE TABLE batches (
+  id TEXT PRIMARY KEY,
+  created_at TEXT NOT NULL
+);
+CREATE TABLE project_queue (
+  position INTEGER PRIMARY KEY AUTOINCREMENT,
+  project_id TEXT NOT NULL UNIQUE REFERENCES projects(id) ON DELETE CASCADE,
+  batch_id TEXT NOT NULL REFERENCES batches(id),
+  state TEXT NOT NULL DEFAULT 'queued' CHECK(state IN ('queued','active','finished'))
+);
+CREATE INDEX project_queue_state ON project_queue(state, position);

package/dist/kernel/ports/llm.js

@@ -1 +1,2 @@
 export const messageRoles = ["system", "user", "assistant"];
+export const thinkingModes = ["off", "low", "medium", "high", "xhigh"];

package/dist/kernel/ports/text.js

@@ -0,0 +1,26 @@
+// Bounded UTF-16 length is conservative for providers counting Unicode characters.
+// Every character survives; the split never cuts a surrogate pair.
+export function splitText(text, limit) {
+    if (!Number.isInteger(limit) || limit < 2)
+        throw new Error("Text limit must be at least two characters");
+    const parts = [];
+    let rest = text;
+    while (rest.length > limit) {
+        const window = rest.slice(0, limit);
+        const sentences = [...window.matchAll(/[.!?]\s+|\n/g)];
+        const last = sentences.at(-1);
+        let cut = last && last.index > limit / 2
+            ? last.index + last[0].length
+            : Math.max(window.lastIndexOf(" "), window.lastIndexOf("\n"), window.lastIndexOf("\t")) + 1;
+        if (cut < limit / 2)
+            cut = limit;
+        const code = rest.charCodeAt(cut - 1);
+        if (code >= 0xd800 && code <= 0xdbff)
+            cut--;
+        parts.push(rest.slice(0, cut));
+        rest = rest.slice(cut);
+    }
+    if (rest)
+        parts.push(rest);
+    return parts;
+}

package/dist/kernel/runner/providers.js

@@ -11,6 +11,7 @@ export function stageProviders(deps, context, pieceId) {
         ...(pieceId === undefined ? {} : { pieceId }),
         signal: context.signal,
     };
+    const schedule = (provider, work) => deps.queue ? deps.queue.run(provider, context.signal, work) : work();
     return {
         llm: (call, onEvent) => {
             // Resolved once; the adapter reads the stored key per request, so a key replaced
@@ -26,13 +27,14 @@ export function stageProviders(deps, context, pieceId) {
                 text,
                 ...(reset === undefined ? {} : { reset }),
             });
-            return attempt(ctx, async (signal, progress) => {
+            return schedule(call.provider, () => attempt(ctx, async (signal, progress) => {
                 preview("", true);
                 let text = "";
                 let usage = null;
                 let finishReason = null;
                 for await (const event of port.complete({
                     model: call.model,
+                    ...(call.thinking === undefined ? {} : { thinking: call.thinking }),
                     messages: call.messages,
                     ...(call.webSearch === undefined ? {} : { webSearch: call.webSearch }),
                     signal,
@@ -58,7 +60,7 @@ export function stageProviders(deps, context, pieceId) {
                     throw new Error(unusable);
                 }
                 return answer;
-            }, { kind: "llm", streaming: port.capabilities.streams });
+            }, { kind: "llm", streaming: port.capabilities.streams }));
         },
         tts: (call, observe) => {
             const port = deps.registry.tts(call.provider);
@@ -76,7 +78,7 @@ export function stageProviders(deps, context, pieceId) {
                     });
                 }
             };
-            return attempt(ctx, async (signal, progress) => {
+            return schedule(call.provider, () => attempt(ctx, async (signal, progress) => {
                 notify({ type: "start" });
                 try {
                     const spoken = await port.synthesize({
@@ -123,18 +125,18 @@ export function stageProviders(deps, context, pieceId) {
                     notify({ type: "interrupted" });
                     throw error;
                 }
-            }, { kind: "tts", streaming: port.capabilities.streams });
+            }, { kind: "tts", streaming: port.capabilities.streams }));
         },
         image: (call) => {
             const port = deps.registry.image(call.provider);
-            return attempt(ctx, (signal) => port.generate({
+            return schedule(call.provider, () => attempt(ctx, (signal) => port.generate({
                 model: call.model,
                 prompt: call.prompt,
                 aspect: call.aspect,
                 signal,
             }), 
             // One request, one answer: the 300 s runs over the whole call.
-            { kind: "image" });
+            { kind: "image" }));
         },
         forPiece: (piece) => stageProviders(deps, context, piece),
     };