ima2-gen 2.0.15 → 2.0.16

package/lib/agentImageVideoGen.js

@@ -19,6 +19,7 @@ import { errInfo } from "./errInfo.js";
 import { forceImagePrompt, isTextOnlyResult, textOnlyError, notFound } from "./agentRuntime.js";
 const AGENT_GROK_PLANNER_MODEL = "grok-4.3";
 export async function generateAgentImageWithRetry(ctx, sessionId, prompt, manifest, webSearchEnabled, options) {
+    options.onProgressStage?.("requesting");
     let lastError = null;
     for (let attempt = 0; attempt < 2; attempt++) {
         try {
@@ -200,6 +201,7 @@ export async function runAgentVideoGeneration(ctx, sessionId, prompt, options =
     const videoModel = videoParams.resolution === "1080p"
         ? GROK_VIDEO_MODEL_15
         : GROK_VIDEO_MODEL_BASE;
+    options.onProgressStage?.("requesting");
     const result = await generateVideoViaGrok(prompt, ctx, {
         model: videoModel,
         mode,
@@ -210,7 +212,13 @@ export async function runAgentVideoGeneration(ctx, sessionId, prompt, options =
         requestId,
         signal: options.signal ?? undefined,
         plannerModel: isAgentGrokPlannerModel(options.model) ? options.model : undefined,
+        onEvent: (event) => {
+            if (event.phase === "submitted" || event.phase === "progress") {
+                options.onProgressStage?.("polling");
+            }
+        },
     });
+    options.onProgressStage?.("downloading");
     const video = await persistAgentVideo(ctx, sessionId, prompt, requestId, result);
     const finishedAt = Date.now();
     const toolCall = {

package/lib/agentQueueStore.js

@@ -32,6 +32,7 @@ export function getAgentQueueItem(id) {
       result_image_ids AS resultImageIds,
       error_code AS errorCode,
       error_message AS errorMessage,
+      progress_stage AS progressStage,
       created_at AS createdAt,
       started_at AS startedAt,
       finished_at AS finishedAt
@@ -55,6 +56,7 @@ export function listAgentQueueItems(sessionId) {
       result_image_ids AS resultImageIds,
       error_code AS errorCode,
       error_message AS errorMessage,
+      progress_stage AS progressStage,
       created_at AS createdAt,
       started_at AS startedAt,
       finished_at AS finishedAt
@@ -93,6 +95,7 @@ export function claimNextAgentQueueItem(limits) {
       result_image_ids AS resultImageIds,
       error_code AS errorCode,
       error_message AS errorMessage,
+      progress_stage AS progressStage,
       created_at AS createdAt,
       started_at AS startedAt,
       finished_at AS finishedAt
@@ -106,7 +109,7 @@ export function claimNextAgentQueueItem(limits) {
             continue;
         const res = getDb().prepare(`
       UPDATE agent_queue_items
-      SET status = 'running', started_at = ?, error_code = NULL, error_message = NULL
+      SET status = 'running', started_at = ?, progress_stage = NULL, error_code = NULL, error_message = NULL
       WHERE id = ? AND status = 'queued'
     `).run(Date.now(), row.id);
         if (res.changes > 0)
@@ -120,9 +123,10 @@ export function completeAgentQueueItem(id, imageIds) {
     SET status = 'succeeded',
         result_image_ids = ?,
         finished_at = ?,
+        progress_stage = NULL,
         error_code = NULL,
         error_message = NULL
-    WHERE id = ?
+    WHERE id = ? AND status = 'running'
   `).run(JSON.stringify([...imageIds]), Date.now(), id);
 }
 export function failAgentQueueItem(id, error) {
@@ -131,18 +135,35 @@ export function failAgentQueueItem(id, error) {
     SET status = 'failed',
         error_code = ?,
         error_message = ?,
-        finished_at = ?
-    WHERE id = ?
+        finished_at = ?,
+        progress_stage = NULL
+    WHERE id = ? AND status = 'running'
   `).run(error.code ?? "AGENT_QUEUE_FAILED", error.message, Date.now(), id);
 }
-export function cancelAgentQueueItem(id) {
+export function cancelAgentQueueItem(id, reason = "Canceled by user") {
     const res = getDb().prepare(`
     UPDATE agent_queue_items
-    SET status = 'canceled', finished_at = ?
-    WHERE id = ? AND status = 'queued'
-  `).run(Date.now(), id);
+    SET status = 'canceled', error_code = 'canceled', error_message = ?, finished_at = ?, progress_stage = NULL
+    WHERE id = ? AND status IN ('queued', 'running')
+  `).run(reason, Date.now(), id);
     return res.changes > 0;
 }
+export function updateAgentQueueItemProgress(id, stage) {
+    const res = getDb().prepare(`
+    UPDATE agent_queue_items SET progress_stage = ?
+    WHERE id = ? AND status = 'running'
+  `).run(stage ?? null, id);
+    return res.changes > 0;
+}
+export function recoverRunningAgentQueueItems() {
+    const res = getDb().prepare(`
+    UPDATE agent_queue_items
+    SET status = 'failed', error_code = 'server_restart', error_message = 'server restarted mid-run',
+        finished_at = ?, progress_stage = NULL
+    WHERE status = 'running'
+  `).run(Date.now());
+    return res.changes;
+}
 export function updateAgentQueueItemPlan(id, plan) {
     const res = getDb().prepare(`
     UPDATE agent_queue_items
@@ -193,6 +214,7 @@ export function retryAgentQueueItem(id) {
         result_image_ids = '[]',
         error_code = NULL,
         error_message = NULL,
+        progress_stage = NULL,
         started_at = NULL,
         finished_at = NULL
     WHERE id = ? AND status IN ('failed', 'canceled')
@@ -211,6 +233,7 @@ function queueItemFromRow(row) {
         resultImageIds: parseStringArray(row.resultImageIds),
         errorCode: row.errorCode,
         errorMessage: row.errorMessage,
+        progressStage: row.progressStage ?? null,
         createdAt: row.createdAt,
         startedAt: row.startedAt,
         finishedAt: row.finishedAt,
@@ -218,10 +241,13 @@ function queueItemFromRow(row) {
         plan: normalizeAgentGenerationPlan(row.prompt, parseJson(row.toolPlan, {}), options),
     };
 }
-function summarizeQueue(items) {
+export function summarizeQueue(items) {
     const queuedCount = items.filter((item) => item.status === "queued").length;
     const runningCount = items.filter((item) => item.status === "running").length;
-    const failed = items.find((item) => item.status === "failed");
+    const latestTerminal = items
+        .filter((item) => ["succeeded", "failed", "canceled"].includes(item.status))
+        .sort((a, b) => (b.finishedAt ?? b.createdAt) - (a.finishedAt ?? a.createdAt))[0];
+    const failed = latestTerminal?.status === "failed" ? latestTerminal : null;
     return {
         status: runningCount > 0 ? "running" : queuedCount > 0 ? "queued" : failed ? "error" : "idle",
         queuedCount,

package/lib/agentQueueWorker.js

@@ -1,10 +1,10 @@
 import { config } from "../config.js";
-import { claimNextAgentQueueItem, completeAgentQueueItem, failAgentQueueItem, getAgentQueueItem, updateAgentQueueItemPlan, } from "./agentQueueStore.js";
+import { claimNextAgentQueueItem, completeAgentQueueItem, failAgentQueueItem, getAgentQueueItem, cancelAgentQueueItem, recoverRunningAgentQueueItems, updateAgentQueueItemProgress, updateAgentQueueItemPlan, } from "./agentQueueStore.js";
 import { requestAgentPlanFromModel } from "./agentPlannerModel.js";
 import { hasAgentErrorTurnRecorded, runAgentGenerationPlan } from "./agentRuntime.js";
 import { appendAgentTurn } from "./agentStore.js";
 import { errInfo } from "./errInfo.js";
-import { finishJob, setJobPhase, startJob } from "./inflight.js";
+import { finishJob, isStartJobFailure, setJobPhase, startJob } from "./inflight.js";
 import { logEvent } from "./logger.js";
 const DEFAULT_LIMITS = {
     maxGlobalRunning: 2,
@@ -12,7 +12,15 @@ const DEFAULT_LIMITS = {
 };
 let workerTimer = null;
 let ticking = false;
+let startupRecovered = false;
+const runningControllers = new Map();
+const IMAGE_TIMEOUT_MS = 10 * 60 * 1_000;
+const VIDEO_TIMEOUT_MS = 30 * 60 * 1_000;
 export function ensureAgentQueueWorker(ctx) {
+    if (!startupRecovered) {
+        recoverRunningAgentQueueItems();
+        startupRecovered = true;
+    }
     if (workerTimer)
         return;
     workerTimer = setInterval(() => {
@@ -26,6 +34,18 @@ export function stopAgentQueueWorker() {
         clearInterval(workerTimer);
         workerTimer = null;
     }
+    for (const controller of runningControllers.values())
+        controller.abort("Worker stopped");
+    runningControllers.clear();
+}
+export function cancelRunningAgentQueueItem(id, reason = "Canceled by user") {
+    const item = getAgentQueueItem(id);
+    if (!item || (item.status !== "queued" && item.status !== "running"))
+        return false;
+    const canceled = cancelAgentQueueItem(id, reason);
+    if (canceled && item.status === "running")
+        runningControllers.get(id)?.abort(reason);
+    return canceled;
 }
 export async function tickAgentQueueWorker(ctx) {
     if (ticking)
@@ -80,8 +100,19 @@ async function runClaimedQueueItem(ctx, itemId) {
     const item = getAgentQueueItem(itemId);
     if (!item)
         return;
+    const controller = new AbortController();
+    runningControllers.set(item.id, controller);
     const plan = await resolveRuntimePlan(ctx, item);
-    startJob({
+    if (controller.signal.aborted) {
+        runningControllers.delete(item.id);
+        return;
+    }
+    const timeoutMs = plan.mode === "video" ? VIDEO_TIMEOUT_MS : IMAGE_TIMEOUT_MS;
+    const timeoutController = new AbortController();
+    const timeout = setTimeout(() => timeoutController.abort("timeout"), timeoutMs);
+    timeout.unref?.();
+    const signal = combineAbortSignals(controller.signal, timeoutController.signal);
+    const started = startJob({
         requestId: item.requestId,
         kind: "agent_queue",
         prompt: item.prompt,
@@ -93,6 +124,15 @@ async function runClaimedQueueItem(ctx, itemId) {
             requestedVariants: plan.requestedVariants,
         },
     });
+    if (started && isStartJobFailure(started)) {
+        clearTimeout(timeout);
+        runningControllers.delete(item.id);
+        const reason = started.code === "TOO_MANY_JOBS"
+            ? "Too many concurrent generation jobs"
+            : "Request ID already in use";
+        failAgentQueueItem(item.id, { code: started.code, message: reason });
+        return;
+    }
     try {
         logEvent("agent_queue", "start", { itemId: item.id, sessionId: item.sessionId });
         setJobPhase(item.requestId, "streaming");
@@ -101,6 +141,8 @@ async function runClaimedQueueItem(ctx, itemId) {
             requestId: item.requestId,
             webSearchEnabled: item.options.webSearchEnabled,
             parallelism: plan.plannedParallelism,
+            signal,
+            onProgressStage: (stage) => updateAgentQueueItemProgress(item.id, stage),
         }, {
             appendUserTurn: false,
         });
@@ -112,8 +154,20 @@ async function runClaimedQueueItem(ctx, itemId) {
         logEvent("agent_queue", "finish", { itemId: item.id, imageCount: result.imageIds.length });
     }
     catch (error) {
+        const current = getAgentQueueItem(item.id);
+        if (current?.status === "canceled") {
+            finishJob(item.requestId, {
+                status: "canceled",
+                errorCode: "canceled",
+                meta: { queueItemId: item.id },
+            });
+            logEvent("agent_queue", "canceled", { itemId: item.id, reason: current.errorMessage });
+            return;
+        }
         const err = errInfo(error);
-        failAgentQueueItem(item.id, { code: err.code, message: err.message });
+        const timedOut = timeoutController.signal.aborted;
+        const failure = timedOut ? { code: "timeout", message: "timeout" } : { code: err.code, message: err.message };
+        failAgentQueueItem(item.id, failure);
         // The chat pane must never fail silently — surface the failure as an
         // assistant error turn unless the runtime already recorded one.
         if (!hasAgentErrorTurnRecorded(error)) {
@@ -121,7 +175,7 @@ async function runClaimedQueueItem(ctx, itemId) {
                 appendAgentTurn({
                     sessionId: item.sessionId,
                     role: "assistant",
-                    text: err.code ? `${err.message} [${err.code}]` : err.message,
+                    text: failure.code ? `${failure.message} [${failure.code}]` : failure.message,
                     status: "error",
                 });
             }
@@ -131,9 +185,27 @@ async function runClaimedQueueItem(ctx, itemId) {
         }
         finishJob(item.requestId, {
             status: "failed",
-            errorCode: err.code,
+            errorCode: failure.code,
             meta: { queueItemId: item.id },
         });
-        logEvent("agent_queue", "error", { itemId: item.id, code: err.code, message: err.message });
+        logEvent("agent_queue", "error", { itemId: item.id, code: failure.code, message: failure.message });
+    }
+    finally {
+        clearTimeout(timeout);
+        runningControllers.delete(item.id);
+    }
+}
+function combineAbortSignals(...signals) {
+    const controller = new AbortController();
+    const abort = (signal) => {
+        if (!controller.signal.aborted)
+            controller.abort(signal.reason);
+    };
+    for (const signal of signals) {
+        if (signal.aborted)
+            abort(signal);
+        else
+            signal.addEventListener("abort", () => abort(signal), { once: true });
     }
+    return controller.signal;
 }

package/lib/agentRuntime.js

@@ -237,6 +237,8 @@ async function runGeneratorWithRuntimeRecovery(ctx, sessionId, prompt, manifest,
         return await generateAgentImageWithRetry(ctx, sessionId, prompt, manifest, webSearchEnabled, options);
     }
     catch (error) {
+        if (options.signal?.aborted)
+            throw error;
         const err = errInfo(error);
         if (isRuntimeRestartableError(error)) {
             restartAgentRuntimeSession(sessionId, err.code || err.message);

package/lib/assetLifecycle.js

@@ -1,5 +1,5 @@
 import { getDb } from "./db.js";
-import { mkdir, rename, unlink, access } from "fs/promises";
+import { mkdir, rename, unlink, lstat, realpath } from "fs/promises";
 import { resolve, sep } from "path";
 import { moveToSystemTrash } from "./systemTrash.js";
 import { config } from "../config.js";
@@ -27,6 +27,23 @@ function resolveInGenerated(rootDir, relPath) {
     }
     return target;
 }
+async function assertRegularGeneratedPath(path) {
+    const baseDir = await realpath(resolve(config.storage.generatedDir));
+    const stat = await lstat(path);
+    if (stat.isSymbolicLink()) {
+        const err = new Error("symbolic links are not valid assets");
+        err.status = 400;
+        err.code = "INVALID_FILENAME";
+        throw err;
+    }
+    const canonical = await realpath(path);
+    if (canonical !== baseDir && !canonical.startsWith(baseDir + sep)) {
+        const err = new Error("filename escapes generated/");
+        err.status = 400;
+        err.code = "INVALID_FILENAME";
+        throw err;
+    }
+}
 function nodesReferencingFilename(filename) {
     // The client stores imageUrl as `/generated/<encoded filename>` in node data JSON.
     // We scan all sessions' nodes for substring match on the decoded and encoded forms.
@@ -72,9 +89,11 @@ function markNodesAssetMissing(filename) {
 export async function trashAsset(rootDir, filename) {
     const src = resolveInGenerated(rootDir, filename);
     try {
-        await access(src);
+        await assertRegularGeneratedPath(src);
     }
-    catch {
+    catch (cause) {
+        if (cause?.code !== "ENOENT")
+            throw cause;
         const err = new Error("Asset not found");
         err.status = 404;
         err.code = "ASSET_NOT_FOUND";
@@ -83,10 +102,13 @@ export async function trashAsset(rootDir, filename) {
     const sidecar = `${src}.json`;
     const paths = [src];
     try {
-        await access(sidecar);
+        await assertRegularGeneratedPath(sidecar);
         paths.push(sidecar);
     }
-    catch { }
+    catch (err) {
+        if (err?.code !== "ENOENT")
+            throw err;
+    }
     let trashMethod = "system";
     try {
         await moveToSystemTrash(paths);
@@ -114,16 +136,26 @@ export async function trashAsset(rootDir, filename) {
 export async function deleteAssetPermanent(rootDir, filename) {
     const src = resolveInGenerated(rootDir, filename);
     try {
-        await access(src);
+        await assertRegularGeneratedPath(src);
     }
-    catch {
+    catch (cause) {
+        if (cause?.code !== "ENOENT")
+            throw cause;
         const err = new Error("Asset not found");
         err.status = 404;
         err.code = "ASSET_NOT_FOUND";
         throw err;
     }
     await unlink(src);
-    await unlink(src + ".json").catch(() => { });
+    const sidecar = src + ".json";
+    try {
+        await assertRegularGeneratedPath(sidecar);
+        await unlink(sidecar);
+    }
+    catch (err) {
+        if (err?.code !== "ENOENT")
+            throw err;
+    }
     const summary = markNodesAssetMissing(filename);
     return {
         ok: true,

package/lib/canvasVersionStore.js

@@ -2,6 +2,7 @@ import { mkdir, writeFile, access, readFile } from "fs/promises";
 import { constants } from "fs";
 import { basename, join, normalize, parse } from "path";
 import { randomBytes } from "crypto";
+import sharp from "sharp";
 import { embedImageMetadataBestEffort } from "./imageMetadataStore.js";
 import { invalidateHistoryIndex } from "./historyIndex.js";
 const PNG_SIGNATURE = "89504e470d0a1a0a";
@@ -99,8 +100,20 @@ function toGenerateItem(filename, meta) {
         canvasVersion: true,
         canvasSourceFilename: meta.canvasSourceFilename || null,
         canvasEditableFilename: filename,
+        annotationsBaked: Boolean(meta.annotationsBaked),
+        annotationSnapshot: meta.annotationSnapshot ?? null,
+        annotationOnly: Boolean(meta.annotationOnly),
     };
 }
+function assertAnnotationSnapshot(value) {
+    const snapshot = value;
+    if (!snapshot || !Array.isArray(snapshot.paths) || !Array.isArray(snapshot.boxes) || !Array.isArray(snapshot.memos)) {
+        const err = new Error("Invalid canvas annotation snapshot");
+        err.status = 400;
+        err.code = "INVALID_CANVAS_ANNOTATION_SNAPSHOT";
+        throw err;
+    }
+}
 export async function createCanvasVersion(ctx, input) {
     assertPngBuffer(input.buffer);
     const sourceFilename = basename(String(input.sourceFilename || ""));
@@ -126,6 +139,9 @@ export async function createCanvasVersion(ctx, input) {
         canvasVersion: true,
         canvasSourceFilename: sourceFilename,
         canvasEditableFilename: filename,
+        annotationsBaked: false,
+        annotationSnapshot: null,
+        annotationOnly: false,
     };
     await writeCanvasPng(ctx, filename, input.buffer, meta);
     return toGenerateItem(filename, meta);
@@ -159,7 +175,77 @@ export async function updateCanvasVersion(ctx, filename, input) {
         canvasVersion: true,
         canvasSourceFilename: sourceFilename,
         canvasEditableFilename: filename,
+        annotationsBaked: Boolean(previousMeta?.annotationsBaked),
+        annotationSnapshot: previousMeta?.annotationSnapshot ?? null,
+        annotationOnly: Boolean(previousMeta?.annotationOnly) && !input.pixelEdited,
     };
     await writeCanvasPng(ctx, filename, input.buffer, meta);
     return toGenerateItem(filename, meta);
 }
+export async function recordCanvasAnnotationBake(ctx, filename, snapshot, annotationOnly) {
+    assertSafeFilename(filename);
+    assertAnnotationSnapshot(snapshot);
+    const full = ensureInsideGeneratedDir(ctx.config.storage.generatedDir, filename);
+    const previousMeta = await readGeneratedMetadata(ctx, filename);
+    if (!previousMeta) {
+        const err = new Error("Canvas version not found");
+        err.status = 404;
+        err.code = "CANVAS_VERSION_NOT_FOUND";
+        throw err;
+    }
+    const buffer = await readFile(full);
+    const meta = {
+        ...previousMeta,
+        kind: "edit",
+        provider: "canvas",
+        format: "png",
+        prompt: previousMeta.prompt,
+        userPrompt: previousMeta.userPrompt,
+        promptMode: previousMeta.promptMode || "direct",
+        createdAt: previousMeta.createdAt || Date.now(),
+        canvasMergedAt: previousMeta.canvasMergedAt || Date.now(),
+        canvasVersion: true,
+        canvasSourceFilename: previousMeta.canvasSourceFilename || null,
+        canvasEditableFilename: filename,
+        annotationsBaked: true,
+        annotationSnapshot: snapshot,
+        annotationOnly,
+    };
+    await writeCanvasPng(ctx, filename, buffer, meta);
+    return toGenerateItem(filename, meta);
+}
+export async function revertCanvasAnnotations(ctx, filename) {
+    assertSafeFilename(filename);
+    const previousMeta = await readGeneratedMetadata(ctx, filename);
+    const sourceFilename = previousMeta?.canvasSourceFilename;
+    if (!previousMeta?.annotationsBaked || !sourceFilename) {
+        const err = new Error("Canvas version has no baked annotations");
+        err.status = 409;
+        err.code = "CANVAS_ANNOTATIONS_NOT_BAKED";
+        throw err;
+    }
+    const sourceFull = ensureInsideGeneratedDir(ctx.config.storage.generatedDir, basename(sourceFilename));
+    const cleanPng = await sharp(await readFile(sourceFull)).png().toBuffer();
+    const snapshot = previousMeta.annotationSnapshot ?? null;
+    const annotationOnly = Boolean(previousMeta.annotationOnly);
+    const now = Date.now();
+    const meta = {
+        ...previousMeta,
+        kind: "edit",
+        provider: "canvas",
+        format: "png",
+        prompt: previousMeta.prompt,
+        userPrompt: previousMeta.userPrompt,
+        promptMode: previousMeta.promptMode || "direct",
+        createdAt: now,
+        canvasMergedAt: now,
+        canvasVersion: true,
+        canvasSourceFilename: sourceFilename,
+        canvasEditableFilename: filename,
+        annotationsBaked: false,
+        annotationSnapshot: null,
+        annotationOnly: false,
+    };
+    await writeCanvasPng(ctx, filename, cleanPng, meta);
+    return { item: toGenerateItem(filename, meta), snapshot, annotationOnly };
+}

package/lib/cardNewsGenerator.js

@@ -7,6 +7,39 @@ import { writeCardNewsManifest, writeCardSidecar } from "./cardNewsManifestStore
 import { invalidateHistoryIndex } from "./historyIndex.js";
 import { requireRuntimeContext } from "./runtimeContext.js";
 import { errInfo } from "./errInfo.js";
+import { assertSafeSetId, resolveCardNewsSetDir } from "./cardNewsPath.js";
+const MAX_CARDS = 30;
+const MAX_CONCURRENCY = 4;
+const MAX_TEXT_CHARS = 20_000;
+const MAX_REFERENCES_PER_CARD = 8;
+const MAX_REFERENCE_CHARS = 10 * 1024 * 1024;
+function inputError(message, code) {
+    throw Object.assign(new Error(message), { status: 400, code });
+}
+function validateInput(input, cards) {
+    if (cards.length > MAX_CARDS)
+        inputError(`cards must contain at most ${MAX_CARDS} items`, "CARD_NEWS_TOO_MANY_CARDS");
+    const concurrency = input.concurrency === undefined ? 2 : Number(input.concurrency);
+    if (!Number.isInteger(concurrency) || concurrency < 1 || concurrency > MAX_CONCURRENCY) {
+        inputError(`concurrency must be an integer between 1 and ${MAX_CONCURRENCY}`, "CARD_NEWS_INVALID_CONCURRENCY");
+    }
+    for (const card of cards) {
+        const text = [card.headline, card.body, card.visualPrompt, ...(Array.isArray(card.textFields) ? card.textFields.map((f) => f?.text) : [])]
+            .filter((value) => typeof value === "string").join("");
+        if (text.length > MAX_TEXT_CHARS)
+            inputError(`card text must not exceed ${MAX_TEXT_CHARS} characters`, "CARD_NEWS_TEXT_TOO_LARGE");
+        const refs = Array.isArray(card.references) ? card.references : [];
+        if (refs.length > MAX_REFERENCES_PER_CARD || refs.some((ref) => typeof ref !== "string" || ref.length > MAX_REFERENCE_CHARS)) {
+            inputError("card references exceed the allowed size", "CARD_NEWS_REFERENCES_TOO_LARGE");
+        }
+    }
+    return concurrency;
+}
+export function validateCardNewsInput(input) {
+    if (input.setId !== undefined)
+        assertSafeSetId(input.setId);
+    validateInput(input, Array.isArray(input.cards) ? input.cards : []);
+}
 function formatRenderedTextInstruction(textFields = []) {
     const visible = (Array.isArray(textFields) ? textFields : [])
         .filter((field) => field?.renderMode === "in-image" && field.text);
@@ -50,8 +83,9 @@ async function mapLimit(items, limit, fn) {
 }
 export async function generateCardNewsSet(ctxIn, input, options = {}) {
     const ctx = requireRuntimeContext(ctxIn);
-    const setId = input.setId || `cs_${ulid()}`;
+    const setId = assertSafeSetId(input.setId || `cs_${ulid()}`);
     const cards = Array.isArray(input.cards) ? input.cards : [];
+    const concurrency = validateInput(input, cards);
     const cardsToGenerate = cards.filter((card) => !card.locked);
     if (cardsToGenerate.length === 0) {
         const err = new Error("cards are required");
@@ -61,14 +95,14 @@ export async function generateCardNewsSet(ctxIn, input, options = {}) {
     }
     const imageTemplateId = input.imageTemplateId || "academy-lesson-square";
     const { template, templateBase, b64: templateB64 } = await readTemplateBaseB64(ctx, imageTemplateId);
-    const dir = join(ctx.config.storage.generatedDir, "cardnews", setId);
+    const dir = resolveCardNewsSetDir(ctx.config.storage.generatedDir, setId);
     await mkdir(dir, { recursive: true });
     const quality = input.quality || "medium";
     const size = input.size || template.size || "2048x2048";
     const moderation = input.moderation || "low";
     const model = input.model || ctx.config.imageModels.default;
     const generateFn = options.generateFn || generateViaOAuth;
-    const generatedCards = await mapLimit(cardsToGenerate, Number(input.concurrency) || 2, async (card, index) => {
+    const generatedCards = await mapLimit(cardsToGenerate, concurrency, async (card, index) => {
         const cardOrder = Number(card.cardOrder || card.order || index + 1);
         const baseFilename = `card-${String(cardOrder).padStart(2, "0")}`;
         const imageFilename = `${baseFilename}.png`;

package/lib/cardNewsJobStore.js

@@ -1,6 +1,8 @@
 import { ulid } from "ulid";
+import { assertSafeSetId } from "./cardNewsPath.js";
 const jobs = new Map();
 const TTL_MS = 30 * 60 * 1000;
+const MAX_ACTIVE_JOBS = 3;
 function summarize(job) {
     const generated = job.cards.filter((card) => card.status === "generated").length;
     const errors = job.cards.filter((card) => card.status === "error").length;
@@ -28,6 +30,14 @@ function statusFromCards(cards) {
     return "done";
 }
 export function createCardNewsJob(plan) {
+    assertSafeSetId(plan.setId);
+    const activeJobs = [...jobs.values()].filter((job) => job.status === "queued" || job.status === "running").length;
+    if (activeJobs >= MAX_ACTIVE_JOBS) {
+        throw Object.assign(new Error(`At most ${MAX_ACTIVE_JOBS} Card News jobs may be active`), {
+            status: 400,
+            code: "CARD_NEWS_ACTIVE_JOB_LIMIT",
+        });
+    }
     const now = Date.now();
     const job = {
         jobId: `cj_${ulid()}`,

package/lib/cardNewsManifestStore.js

@@ -2,8 +2,9 @@ import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { requireRuntimeContext } from "./runtimeContext.js";
 import { errInfo } from "./errInfo.js";
+import { assertSafeSetId, resolveCardNewsSetDir } from "./cardNewsPath.js";
 export async function writeCardNewsManifest(generatedDir, manifest) {
-    const dir = join(generatedDir, "cardnews", manifest.setId);
+    const dir = resolveCardNewsSetDir(generatedDir, manifest.setId);
     await mkdir(dir, { recursive: true });
     await writeFile(join(dir, "manifest.json"), JSON.stringify(manifest, null, 2));
     return { dir, manifestFilename: "manifest.json" };
@@ -16,14 +17,6 @@ function cardUrl(setId, imageFilename) {
         return undefined;
     return `/generated/cardnews/${encodeURIComponent(setId)}/${encodeURIComponent(imageFilename)}`;
 }
-function assertSafeSetId(setId) {
-    if (typeof setId === "string" && /^[a-zA-Z0-9_-]{3,120}$/.test(setId))
-        return setId;
-    const err = new Error("Card News set not found");
-    err.status = 404;
-    err.code = "CARD_NEWS_SET_NOT_FOUND";
-    throw err;
-}
 function manifestToPlan(manifest) {
     return {
         setId: manifest.setId,
@@ -57,9 +50,9 @@ export async function readCardNewsSetPlan(ctxIn, setId) {
 }
 export async function readCardNewsManifest(ctxIn, setId) {
     const ctx = requireRuntimeContext(ctxIn);
-    const safeSetId = assertSafeSetId(setId);
+    const safeSetId = assertSafeSetId(setId, 404);
     try {
-        const raw = await readFile(join(ctx.config.storage.generatedDir, "cardnews", safeSetId, "manifest.json"), "utf8");
+        const raw = await readFile(join(resolveCardNewsSetDir(ctx.config.storage.generatedDir, safeSetId, 404), "manifest.json"), "utf8");
         return JSON.parse(raw);
     }
     catch (err) {
@@ -80,7 +73,8 @@ export async function listCardNewsSets(ctxIn) {
         if (!entry.isDirectory())
             continue;
         try {
-            const raw = await readFile(join(root, entry.name, "manifest.json"), "utf8");
+            const safeSetId = assertSafeSetId(entry.name, 404);
+            const raw = await readFile(join(resolveCardNewsSetDir(ctx.config.storage.generatedDir, safeSetId, 404), "manifest.json"), "utf8");
             const manifest = JSON.parse(raw);
             const first = (manifest.cards || []).find((card) => card.imageFilename);
             sets.push({