ima2-gen 3.14.0 → 3.15.0

package/lib/providers/execution/legacyClassic.js

@@ -1,66 +1,6 @@
-import { generateViaAtlasCloud } from "../../atlasCloudImageAdapter.js";
-import { generateViaMinimax } from "../../minimaxImageAdapter.js";
-import { generateViaNai } from "../../naiImageAdapter.js";
-import { generateViaComfy } from "../../comfyImageAdapter.js";
-import { requireRuntimeContext } from "../../runtimeContext.js";
-function captureClassicRequest(request) {
-    const { provider: activeProvider, prompt: generationPrompt, requestId, background: backgroundParams } = request;
-    const { model: imageModel, quality, size: effectiveSize } = request.options;
-    return { activeProvider, generationPrompt, requestId, backgroundParams, imageModel, quality, effectiveSize };
-}
-async function executeLegacyClassic(ctx, request, progress, captured) {
-    try {
-        const { activeProvider, generationPrompt, requestId, backgroundParams, imageModel, quality, effectiveSize } = captured;
-        if (activeProvider === "atlascloud") {
-            return await generateViaAtlasCloud(generationPrompt, requireRuntimeContext(ctx), {
-                model: imageModel, size: effectiveSize, quality, signal: request.signal,
-                requestId, references: request.references,
-                ...(backgroundParams ? { background: backgroundParams.background } : {}),
-                // The caller's resolveImageBackgroundParams validates this alpha-only format.
-                ...(backgroundParams?.outputFormat ? { outputFormat: backgroundParams.outputFormat } : {}),
-            });
-        }
-        if (activeProvider === "minimax") {
-            return await generateViaMinimax(generationPrompt, requireRuntimeContext(ctx), {
-                model: imageModel, size: effectiveSize, signal: request.signal,
-                requestId, references: request.references,
-            });
-        }
-        if (activeProvider === "nai") {
-            // Text-to-image only: the caller already refused references.
-            return await generateViaNai(generationPrompt, requireRuntimeContext(ctx), {
-                model: imageModel, size: effectiveSize, signal: request.signal, requestId,
-                // Reuse the same normalized options as node and multimode.
-                ...request.nai,
-            });
-        }
-        if (activeProvider === "comfy") {
-            return await generateViaComfy(generationPrompt, requireRuntimeContext(ctx), {
-                model: imageModel, size: effectiveSize, signal: request.signal,
-                requestId, references: request.references,
-                ...request.comfy, onQueue: progress.onQueue,
-            });
-        }
-        throw new Error(`Unsupported classic execution provider: ${activeProvider}`);
-    }
-    catch (error) {
-        throw error;
-    }
-}
-export async function prepareLegacyClassic(ctx, request, progress = {}) {
-    try {
-        // Preserve scalar/background capture; ctx, refs, signal and lane options stay live.
-        const captured = captureClassicRequest(request);
-        return { execute: async () => {
-                try {
-                    return { kind: "single", value: await executeLegacyClassic(ctx, request, progress, captured) };
-                }
-                catch (error) {
-                    throw error;
-                } // Caller owns lifecycle and the existing error envelope.
-            } };
-    }
-    catch (error) {
-        throw error;
-    }
+export async function prepareLegacyClassic(_ctx, request, _progress) {
+    const { provider } = request;
+    return { execute: async () => {
+            throw new Error(`Unsupported classic execution provider: ${provider}`);
+        } };
 }

package/lib/providers/execution/legacyEdit.js

@@ -1,30 +1,5 @@
-import { detectImageMimeFromB64 } from "../../refs.js";
-import { generateViaAtlasCloud } from "../../atlasCloudImageAdapter.js";
-import { generateViaMinimax } from "../../minimaxImageAdapter.js";
-import { generateViaComfy } from "../../comfyImageAdapter.js";
-function executeImageToImage(ctx, request) {
-    const { provider, prompt, sourceImage, signal, requestId, options } = request;
-    const references = [{ b64: sourceImage, declaredMime: null, detectedMime: detectImageMimeFromB64(sourceImage) || null }];
-    const editPrompt = `Edit this image: ${prompt}`;
-    const params = { model: options.model, size: options.size, signal, ...(requestId !== undefined ? { requestId } : {}), references };
-    switch (provider) {
-        case "atlascloud": return generateViaAtlasCloud(editPrompt, ctx, { ...params, quality: options.quality });
-        case "minimax": return generateViaMinimax(editPrompt, ctx, params);
-        // LoadImage binding owns i2i; missing workflow binding still refuses there.
-        case "comfy": return generateViaComfy(editPrompt, ctx, params);
-        default: throw new Error(`Unsupported legacy edit provider: ${provider}`);
-    }
-}
-async function executeEdit(ctx, request) {
-    return executeImageToImage(ctx, request);
-}
-export async function prepareLegacyEdit(ctx, request, _progress) {
+export async function prepareLegacyEdit(_ctx, request, _progress) {
     return { execute: async () => {
-            try {
-                return { kind: "single", value: await executeEdit(ctx, request) };
-            }
-            catch (error) {
-                throw error;
-            } // Route owns failure normalization and job cleanup.
+            throw new Error(`Unsupported legacy edit provider: ${request.provider}`);
         } };
 }

package/lib/providers/execution/legacyMultimode.js

@@ -1,34 +1,5 @@
-import { generateViaAtlasCloud } from "../../atlasCloudImageAdapter.js";
-import { generateViaMinimax } from "../../minimaxImageAdapter.js";
-import { generateViaNai } from "../../naiImageAdapter.js";
-function executeSingleLane(ctx, request) {
-    const { provider, rawPrompt, references, signal, requestId, options } = request;
-    const params = { model: options.model, size: options.size, signal, ...(requestId !== undefined ? { requestId } : {}), references };
-    switch (provider) {
-        case "atlascloud": return generateViaAtlasCloud(rawPrompt, ctx, { ...params, quality: options.quality });
-        case "minimax": return generateViaMinimax(rawPrompt, ctx, params);
-        // Text-to-image only: no references; admission rejects them before startJob.
-        case "nai": return generateViaNai(rawPrompt, ctx, {
-            model: options.model, size: options.size, signal, requestId, ...request.nai,
-        });
-        default: throw new Error(`Unsupported legacy multimode provider: ${provider}`);
-    }
-}
-async function executeSequence(ctx, request, _progress) {
-    const result = await executeSingleLane(ctx, request);
-    // Preserve the old per-lane projection: downstream detects bytes, not MIME here.
-    return {
-        images: [{ b64: result.b64, ...(result.revisedPrompt !== undefined ? { revisedPrompt: result.revisedPrompt } : {}) }],
-        usage: result.usage, webSearchCalls: result.webSearchCalls,
-    };
-}
-export async function prepareLegacyMultimode(ctx, request, progress = {}) {
+export async function prepareLegacyMultimode(_ctx, request, _progress) {
     return { execute: async () => {
-            try {
-                return { kind: "sequence", value: await executeSequence(ctx, request, progress) };
-            }
-            catch (error) {
-                throw error;
-            } // Preserve native errors; caller owns timeout recovery.
+            throw new Error(`Unsupported legacy multimode provider: ${request.provider}`);
         } };
 }

package/lib/providers/execution/legacyNode.js

@@ -1,41 +1,5 @@
-import { generateViaAtlasCloud } from "../../atlasCloudImageAdapter.js";
-import { generateViaMinimax } from "../../minimaxImageAdapter.js";
-import { generateViaNai } from "../../naiImageAdapter.js";
-import { requireRuntimeContext } from "../../runtimeContext.js";
-export async function prepareLegacyNode(ctx, request, _progress) {
+export async function prepareLegacyNode(_ctx, request, _progress) {
     return { execute: async () => {
-            try {
-                return { kind: "single", value: await executeNodeAttempt(ctx, request) };
-            }
-            catch (error) {
-                throw error;
-            } // The caller owns retries and normalization.
+            throw new Error(`Unsupported node execution provider: ${request.provider}`);
         } };
 }
-// Keep the legacy one-attempt branches together; retry/lifecycle stays at the caller.
-async function executeNodeAttempt(ctx, request) {
-    const { provider, sourceImage: parentB64, rawPrompt: prompt, references, requestId, signal, options } = request;
-    const { model, size, quality } = options;
-    return provider === "atlascloud"
-        ? await generateViaAtlasCloud(parentB64 ? `Edit this image: ${prompt}` : prompt, requireRuntimeContext(ctx), {
-            model, size, quality, signal, requestId,
-            references: parentB64
-                ? [{ b64: parentB64, declaredMime: null, detectedMime: null }, ...references]
-                : references,
-        })
-        : provider === "minimax"
-            ? await generateViaMinimax(parentB64 ? `Edit this image: ${prompt}` : prompt, requireRuntimeContext(ctx), {
-                model, size, signal, requestId,
-                references: parentB64
-                    ? [{ b64: parentB64, declaredMime: null, detectedMime: null }, ...references]
-                    : references,
-            })
-            : provider === "nai"
-                ? await generateViaNai(prompt, requireRuntimeContext(ctx), {
-                    model, size, signal, requestId, ...request.nai,
-                })
-                : unsupportedNodeProvider(provider);
-}
-function unsupportedNodeProvider(provider) {
-    throw new Error(`Unsupported node execution provider: ${provider}`);
-}

package/lib/spriteAnchor.js

@@ -1,32 +1,22 @@
 import { getAsset } from "./assetsStore.js";
 import { spriteRecipeStore, spriteStoreError } from "./spriteRecipeStore.js";
 export async function approveSpriteAnchor(recipeId, candidateAssetId) {
-    try {
-        const recipe = await spriteRecipeStore.approveAnchor(recipeId, candidateAssetId);
-        const asset = getAsset(recipe.anchorAssetId);
-        if (!asset)
-            throw spriteStoreError(404, "ANCHOR_ASSET_NOT_FOUND", "anchor asset not found");
-        return { asset, assetId: asset.id };
-    }
-    catch (error) {
-        throw error;
-    }
+    const recipe = await spriteRecipeStore.approveAnchor(recipeId, candidateAssetId);
+    const asset = getAsset(recipe.anchorAssetId);
+    if (!asset)
+        throw spriteStoreError(404, "ANCHOR_ASSET_NOT_FOUND", "anchor asset not found");
+    return { asset, assetId: asset.id };
 }
 export async function requireApprovedSpriteAnchor(recipeId) {
-    try {
-        const recipe = await spriteRecipeStore.get(recipeId);
-        if (!recipe)
-            throw spriteStoreError(404, "SPRITE_RECIPE_NOT_FOUND", "sprite recipe not found");
-        if (recipe.anchorStatus !== "approved" || !recipe.anchorAssetId)
-            throw spriteStoreError(400, "ANCHOR_NOT_APPROVED", "an approved idle anchor is required");
-        const asset = getAsset(recipe.anchorAssetId);
-        if (!asset || asset.kind !== "image" || !asset.filePath)
-            throw spriteStoreError(400, "ANCHOR_NOT_APPROVED", "approved anchor is no longer available");
-        return { asset, assetId: asset.id };
-    }
-    catch (error) {
-        throw error;
-    }
+    const recipe = await spriteRecipeStore.get(recipeId);
+    if (!recipe)
+        throw spriteStoreError(404, "SPRITE_RECIPE_NOT_FOUND", "sprite recipe not found");
+    if (recipe.anchorStatus !== "approved" || !recipe.anchorAssetId)
+        throw spriteStoreError(400, "ANCHOR_NOT_APPROVED", "an approved idle anchor is required");
+    const asset = getAsset(recipe.anchorAssetId);
+    if (!asset || asset.kind !== "image" || !asset.filePath)
+        throw spriteStoreError(400, "ANCHOR_NOT_APPROVED", "approved anchor is no longer available");
+    return { asset, assetId: asset.id };
 }
 export function buildSpriteRowReferences(input) {
     const refs = [{ role: "identity", assetId: input.anchor.assetId, path: input.anchor.asset.filePath ?? undefined }, { role: "layout", path: input.guide.relativePath, data: input.guide.buffer.toString("base64") }];

package/lib/spriteAtlasExport.js

@@ -1,17 +1,12 @@
 import { rename } from "node:fs/promises";
 import sharp from "sharp";
 export async function composeContactSheet(input) {
-    try {
-        if (!input.frames.length)
-            throw new Error("Contact sheet requires at least one frame");
-        const columns = Math.max(1, input.columns ?? Math.ceil(Math.sqrt(input.frames.length)));
-        const rows = Math.ceil(input.frames.length / columns);
-        const overlays = await Promise.all(input.frames.map(async (path, index) => ({ input: await sharp(path).ensureAlpha().resize(input.cellWidth, input.cellHeight, { fit: "contain" }).png().toBuffer(), left: (index % columns) * input.cellWidth, top: Math.floor(index / columns) * input.cellHeight })));
-        const temp = `${input.outputPath}.${process.pid}.tmp.png`;
-        await sharp({ create: { width: columns * input.cellWidth, height: rows * input.cellHeight, channels: 4, background: { r: 0, g: 0, b: 0, alpha: 0 } } }).composite(overlays).png().toFile(temp);
-        await rename(temp, input.outputPath);
-    }
-    catch (error) {
-        throw error;
-    }
+    if (!input.frames.length)
+        throw new Error("Contact sheet requires at least one frame");
+    const columns = Math.max(1, input.columns ?? Math.ceil(Math.sqrt(input.frames.length)));
+    const rows = Math.ceil(input.frames.length / columns);
+    const overlays = await Promise.all(input.frames.map(async (path, index) => ({ input: await sharp(path).ensureAlpha().resize(input.cellWidth, input.cellHeight, { fit: "contain" }).png().toBuffer(), left: (index % columns) * input.cellWidth, top: Math.floor(index / columns) * input.cellHeight })));
+    const temp = `${input.outputPath}.${process.pid}.tmp.png`;
+    await sharp({ create: { width: columns * input.cellWidth, height: rows * input.cellHeight, channels: 4, background: { r: 0, g: 0, b: 0, alpha: 0 } } }).composite(overlays).png().toFile(temp);
+    await rename(temp, input.outputPath);
 }

package/lib/spriteCurationStore.js

@@ -38,13 +38,8 @@ export async function readSpriteCuration(generatedDir, runId) {
     }
 }
 export async function writeSpriteCuration(generatedDir, runId, input) {
-    try {
-        const value = curationSchema.parse(input);
-        const dir = resolveSpriteRunDir(generatedDir, runId);
-        await mkdir(dir, { recursive: true });
-        await atomicWriteJson(join(dir, "curation.json"), value);
-    }
-    catch (error) {
-        throw error;
-    }
+    const value = curationSchema.parse(input);
+    const dir = resolveSpriteRunDir(generatedDir, runId);
+    await mkdir(dir, { recursive: true });
+    await atomicWriteJson(join(dir, "curation.json"), value);
 }

package/lib/spriteRecipeStore.js

@@ -19,81 +19,18 @@ function syncRows(id, recipe, now) { const db = getDb(); const keys = recipe.sta
     insert.run(id, key, now); if (keys.length)
     db.prepare(`DELETE FROM sprite_recipe_rows WHERE recipe_id = ? AND state_key NOT IN (${keys.map(() => "?").join(",")})`).run(id, ...keys); }
 class SqliteSpriteRecipeStore {
-    async list() { try {
-        return getDb().prepare(`${SELECT} ORDER BY updated_at DESC`).all().map(mapRow);
-    }
-    catch (error) {
-        throw error;
-    } }
-    async get(id) { try {
-        const row = find(id);
-        return row ? mapRow(row) : null;
-    }
-    catch (error) {
-        throw error;
-    } }
-    async create(input) { try {
-        const recipe = normalizeSpriteRecipe(input.recipe);
-        const id = `sr_${ulid()}`;
-        const now = Date.now();
-        const db = getDb();
-        db.transaction(() => { db.prepare("INSERT INTO sprite_recipes (id,name,recipe,created_at,updated_at) VALUES (?,?,?,?,?)").run(id, nameOf(input.name), JSON.stringify(recipe), now, now); syncRows(id, recipe, now); })();
-        return mapRow(requireRecipe(id));
-    }
-    catch (error) {
-        throw error;
-    } }
-    async update(id, patch) { try {
-        const current = mapRow(requireRecipe(id));
-        const recipe = patch.recipe === undefined ? current.recipe : normalizeSpriteRecipe(patch.recipe);
-        const name = patch.name === undefined ? current.name : nameOf(patch.name);
-        const now = Date.now();
-        const db = getDb();
-        db.transaction(() => { db.prepare("UPDATE sprite_recipes SET name=?, recipe=?, updated_at=? WHERE id=?").run(name, JSON.stringify(recipe), now, id); syncRows(id, recipe, now); })();
-        return mapRow(requireRecipe(id));
-    }
-    catch (error) {
-        throw error;
-    } }
-    async setAnchorCandidate(id, assetId) { try {
-        requireRecipe(id);
-        const asset = getDb().prepare("SELECT kind FROM assets WHERE id=?").get(assetId);
-        if (!asset || asset.kind !== "image")
-            throw spriteStoreError(400, "INVALID_ANCHOR_ASSET", "anchor candidate must be an image");
-        getDb().prepare("UPDATE sprite_recipes SET anchor_asset_id=?, anchor_status='candidate', updated_at=? WHERE id=?").run(assetId, Date.now(), id);
-        return mapRow(requireRecipe(id));
-    }
-    catch (error) {
-        throw error;
-    } }
-    async approveAnchor(id, assetId) { try {
-        requireRecipe(id);
-        const asset = getDb().prepare("SELECT kind FROM assets WHERE id=?").get(assetId);
-        if (!asset)
-            throw spriteStoreError(404, "ANCHOR_ASSET_NOT_FOUND", "anchor asset not found");
-        if (asset.kind !== "image")
-            throw spriteStoreError(400, "INVALID_ANCHOR_ASSET", "anchor asset must be an image");
-        getDb().prepare("UPDATE sprite_recipes SET anchor_asset_id=?, anchor_status='approved', updated_at=? WHERE id=?").run(assetId, Date.now(), id);
-        return mapRow(requireRecipe(id));
-    }
-    catch (error) {
-        throw error;
-    } }
-    async updateRow(id, stateKey, patch) { try {
-        const current = mapRow(requireRecipe(id));
-        if (!current.recipe.states.some((state) => state.key === stateKey))
-            throw spriteStoreError(404, "SPRITE_STATE_NOT_FOUND", "sprite state not found");
-        getDb().prepare("UPDATE sprite_recipe_rows SET status=COALESCE(?,status), request_id=COALESCE(?,request_id), result_asset_id=COALESCE(?,result_asset_id), error_code=?, updated_at=? WHERE recipe_id=? AND state_key=?").run(patch.status ?? null, patch.requestId ?? null, patch.resultAssetId ?? null, patch.errorCode ?? null, Date.now(), id, stateKey);
-    }
-    catch (error) {
-        throw error;
-    } }
-    async remove(id) { try {
-        if (getDb().prepare("DELETE FROM sprite_recipes WHERE id=?").run(id).changes === 0)
-            throw spriteStoreError(404, "SPRITE_RECIPE_NOT_FOUND", "sprite recipe not found");
-    }
-    catch (error) {
-        throw error;
-    } }
+    async list() { return getDb().prepare(`${SELECT} ORDER BY updated_at DESC`).all().map(mapRow); }
+    async get(id) { const row = find(id); return row ? mapRow(row) : null; }
+    async create(input) { const recipe = normalizeSpriteRecipe(input.recipe); const id = `sr_${ulid()}`; const now = Date.now(); const db = getDb(); db.transaction(() => { db.prepare("INSERT INTO sprite_recipes (id,name,recipe,created_at,updated_at) VALUES (?,?,?,?,?)").run(id, nameOf(input.name), JSON.stringify(recipe), now, now); syncRows(id, recipe, now); })(); return mapRow(requireRecipe(id)); }
+    async update(id, patch) { const current = mapRow(requireRecipe(id)); const recipe = patch.recipe === undefined ? current.recipe : normalizeSpriteRecipe(patch.recipe); const name = patch.name === undefined ? current.name : nameOf(patch.name); const now = Date.now(); const db = getDb(); db.transaction(() => { db.prepare("UPDATE sprite_recipes SET name=?, recipe=?, updated_at=? WHERE id=?").run(name, JSON.stringify(recipe), now, id); syncRows(id, recipe, now); })(); return mapRow(requireRecipe(id)); }
+    async setAnchorCandidate(id, assetId) { requireRecipe(id); const asset = getDb().prepare("SELECT kind FROM assets WHERE id=?").get(assetId); if (!asset || asset.kind !== "image")
+        throw spriteStoreError(400, "INVALID_ANCHOR_ASSET", "anchor candidate must be an image"); getDb().prepare("UPDATE sprite_recipes SET anchor_asset_id=?, anchor_status='candidate', updated_at=? WHERE id=?").run(assetId, Date.now(), id); return mapRow(requireRecipe(id)); }
+    async approveAnchor(id, assetId) { requireRecipe(id); const asset = getDb().prepare("SELECT kind FROM assets WHERE id=?").get(assetId); if (!asset)
+        throw spriteStoreError(404, "ANCHOR_ASSET_NOT_FOUND", "anchor asset not found"); if (asset.kind !== "image")
+        throw spriteStoreError(400, "INVALID_ANCHOR_ASSET", "anchor asset must be an image"); getDb().prepare("UPDATE sprite_recipes SET anchor_asset_id=?, anchor_status='approved', updated_at=? WHERE id=?").run(assetId, Date.now(), id); return mapRow(requireRecipe(id)); }
+    async updateRow(id, stateKey, patch) { const current = mapRow(requireRecipe(id)); if (!current.recipe.states.some((state) => state.key === stateKey))
+        throw spriteStoreError(404, "SPRITE_STATE_NOT_FOUND", "sprite state not found"); getDb().prepare("UPDATE sprite_recipe_rows SET status=COALESCE(?,status), request_id=COALESCE(?,request_id), result_asset_id=COALESCE(?,result_asset_id), error_code=?, updated_at=? WHERE recipe_id=? AND state_key=?").run(patch.status ?? null, patch.requestId ?? null, patch.resultAssetId ?? null, patch.errorCode ?? null, Date.now(), id, stateKey); }
+    async remove(id) { if (getDb().prepare("DELETE FROM sprite_recipes WHERE id=?").run(id).changes === 0)
+        throw spriteStoreError(404, "SPRITE_RECIPE_NOT_FOUND", "sprite recipe not found"); }
 }
 export const spriteRecipeStore = new SqliteSpriteRecipeStore();

package/lib/spriteRowPipeline.js

@@ -12,32 +12,15 @@ import { spriteRecipeStore, spriteStoreError } from "./spriteRecipeStore.js";
 import { buildSpriteRowPrompt } from "./spriteRowPrompt.js";
 function requestId(req) { const raw = req.body?.requestId; return typeof raw === "string" && raw.trim() ? raw.trim().slice(0, 200) : req.id || `sprite_${Date.now().toString(36)}`; }
 function setSse(res) { res.setHeader("Content-Type", "text/event-stream; charset=utf-8"); res.setHeader("Cache-Control", "no-cache, no-transform"); res.setHeader("Connection", "keep-alive"); res.flushHeaders?.(); }
-async function requireRecipe(id) { try {
-    const recipe = await spriteRecipeStore.get(id);
-    if (!recipe)
-        throw spriteStoreError(404, "SPRITE_RECIPE_NOT_FOUND", "sprite recipe not found");
-    return recipe;
-}
-catch (error) {
-    throw error;
-} }
+async function requireRecipe(id) { const recipe = await spriteRecipeStore.get(id); if (!recipe)
+    throw spriteStoreError(404, "SPRITE_RECIPE_NOT_FOUND", "sprite recipe not found"); return recipe; }
 function selectStates(recipe, raw) { if (raw === undefined)
     return recipe.recipe.states; if (!Array.isArray(raw) || raw.some((key) => typeof key !== "string"))
     throw spriteStoreError(400, "INVALID_SPRITE_RECIPE", "states must be an array of state keys"); const wanted = new Set(raw); const selected = recipe.recipe.states.filter((state) => wanted.has(state.key)); if (selected.length !== wanted.size)
     throw spriteStoreError(404, "SPRITE_STATE_NOT_FOUND", "sprite state not found"); return selected; }
-async function references(recipe, guidePath, anchorMode) { try {
-    const assetId = anchorMode === "approved-anchor" ? recipe.anchorAssetId : recipe.recipe.character.baseAssetId;
-    if (!assetId)
-        throw spriteStoreError(400, anchorMode === "approved-anchor" ? "ANCHOR_NOT_APPROVED" : "INVALID_ANCHOR_ASSET", "reference asset is required");
-    const row = (await import("./assetsStore.js")).getAsset(assetId);
-    if (!row?.filePath || row.kind !== "image")
-        throw spriteStoreError(400, "INVALID_ANCHOR_ASSET", "reference asset must be an image file");
-    const [identity, guide] = await Promise.all([readFile(join((await import("../config.js")).config.storage.generatedDir, row.filePath)), readFile(guidePath)]);
-    return [`data:image/png;base64,${identity.toString("base64")}`, `data:image/png;base64,${guide.toString("base64")}`];
-}
-catch (error) {
-    throw error;
-} }
+async function references(recipe, guidePath, anchorMode) { const assetId = anchorMode === "approved-anchor" ? recipe.anchorAssetId : recipe.recipe.character.baseAssetId; if (!assetId)
+    throw spriteStoreError(400, anchorMode === "approved-anchor" ? "ANCHOR_NOT_APPROVED" : "INVALID_ANCHOR_ASSET", "reference asset is required"); const row = (await import("./assetsStore.js")).getAsset(assetId); if (!row?.filePath || row.kind !== "image")
+    throw spriteStoreError(400, "INVALID_ANCHOR_ASSET", "reference asset must be an image file"); const [identity, guide] = await Promise.all([readFile(join((await import("../config.js")).config.storage.generatedDir, row.filePath)), readFile(guidePath)]); return [`data:image/png;base64,${identity.toString("base64")}`, `data:image/png;base64,${guide.toString("base64")}`]; }
 async function generateRow(input) {
     try {
         await spriteRecipeStore.updateRow(input.recipe.id, input.state.key, { status: "running", requestId: input.requestId, errorCode: null });

package/node_modules/zod/README.md

@@ -113,6 +113,33 @@ await schema.parseAsync("hello");
 // => "hello"
 ```
 
+### AOT compilation
+
+For hot validation paths, `z.compile(schema)` returns a schema clone with an ahead-of-time compiled fast path. Valid inputs take the compiled path; invalid inputs fall back to the regular parser so error reporting stays identical.
+
+Across a 55-schema benchmark the median speedup is **2.4x**, and it scales with how much work the schema does per parse: a large array of objects is ~9x, a 20-key object ~9x, a nested object ~4.5x, while a bare `z.string()` gains nothing — compilation removes per-node dispatch and allocation, and a single `typeof` has none to remove.
+
+```ts
+const CompiledPlayer = z.compile(Player);
+
+CompiledPlayer.parse({ username: "billie", xp: 100 });
+```
+
+To enable compilation globally for schemas constructed after import:
+
+```ts
+import "zod/compile"; // place before modules that define schemas
+```
+
+Things to know:
+
+- Compilation uses `new Function`. Global mode is automatically disabled when `z.config({ jitless: true })` is set (e.g. CSP environments); calling `z.compile()` directly is an explicit opt-in.
+- Schemas with async refinements or transforms can't be compiled, and neither can a few other constructs. That is not an error: `z.compile()` hands the schema back unchanged and it keeps using the regular parser, exactly as global mode leaves it. Pass `{ strict: true }` to throw `ZodCompileAsyncError` / `ZodCompileUnsupportedError` instead.
+- On invalid input, refinements and transforms may run twice (fast path, then fallback).
+- Deriving a new schema from a compiled one (`.refine()`, `.extend()`, etc.) returns an uncompiled schema — compile the final schema.
+
+See [`compile` docs](https://zod.dev/compile) for details.
+
 ### Handling errors
 
 When validation fails, the `.parse()` method will throw a `ZodError` instance with granular information about the validation issues.

package/node_modules/zod/compile.cjs

@@ -0,0 +1,77 @@
+"use strict";
+// Side-effect-only: installs the post-processor on `globalConfig`. Listed in `package.json`'s `sideEffects`, and nothing else references it, so apps that never import it drop the compiler.
+//
+// Usage:
+//
+//   import "zod/compile";
+//   import * as z from "zod";
+//   // every schema constructed below this is compiled on first parse
+//
+// Module evaluation order matters: schemas constructed in modules that evaluate before this import will not be compiled. Place this import in the app entry point, before any module that constructs schemas at top level.
+//
+// Failure handling: if the compiler refuses a schema (async refinement, unsupported feature, etc.) the shim permanently restores the runtime `_zod.run` for that schema. The schema continues to work via the regular runtime parser — no observable difference to the caller.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_js_1 = require("./v4/core/compile.cjs");
+const core = __importStar(require("./v4/core/index.cjs"));
+let compiling = false;
+core.globalConfig.postProcessor = (inst) => {
+    if (compiling)
+        return;
+    const originalRun = inst._zod?.run;
+    if (typeof originalRun !== "function")
+        return;
+    const shim = (payload, ctx) => {
+        // Bypass the fast path for any non-forward / non-sync / check-skipping call. The runtime owns those contracts.
+        if (ctx?.async || ctx?.direction === "backward" || ctx?.skipChecks) {
+            return originalRun(payload, ctx);
+        }
+        compiling = true;
+        try {
+            // Respect the jitless config: it exists precisely so CSP/no-eval environments never reach `new Function`. Global mode must not bypass it (explicit z.compile calls remain an explicit opt-in).
+            if (core.globalConfig.jitless) {
+                inst._zod.run = originalRun;
+                return originalRun(payload, ctx);
+            }
+            // Strict: the shim owns its own fallback below, and a non-strict compile would hand back `inst` — whose run is this shim — and reinstall it on itself.
+            const compiled = (0, compile_js_1.compile)(inst, { strict: true });
+            // Only the run wrapper. Copying the compiled parse/safeParse closures would make their fallback re-enter this instance and run user callbacks a third time.
+            inst._zod.run = compiled._zod.run;
+            inst._zod.bag.fallbackRun = compiled._zod.bag.fallbackRun;
+            inst._zod.bag.validator = compiled._zod.bag.validator;
+        }
+        catch {
+            // Permanent fallback for unsupported schemas.
+            inst._zod.run = originalRun;
+        }
+        finally {
+            compiling = false;
+        }
+        return inst._zod.run(payload, ctx);
+    };
+    // Expose the pre-shim runtime so `compile()` invoked elsewhere can unwrap past the shim and capture the source-of-truth runtime. Without this, a user calling `z.compile(s)` after global mode is enabled would capture the shim itself, which would feed the wrapper into itself on fallback.
+    shim.__originalRun = originalRun;
+    inst._zod.run = shim;
+};

package/node_modules/zod/compile.d.cts

@@ -0,0 +1 @@
+export {};

package/node_modules/zod/compile.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/zod/compile.js

@@ -0,0 +1,52 @@
+// Side-effect-only: installs the post-processor on `globalConfig`. Listed in `package.json`'s `sideEffects`, and nothing else references it, so apps that never import it drop the compiler.
+//
+// Usage:
+//
+//   import "zod/compile";
+//   import * as z from "zod";
+//   // every schema constructed below this is compiled on first parse
+//
+// Module evaluation order matters: schemas constructed in modules that evaluate before this import will not be compiled. Place this import in the app entry point, before any module that constructs schemas at top level.
+//
+// Failure handling: if the compiler refuses a schema (async refinement, unsupported feature, etc.) the shim permanently restores the runtime `_zod.run` for that schema. The schema continues to work via the regular runtime parser — no observable difference to the caller.
+import { compile } from "./v4/core/compile.js";
+import * as core from "./v4/core/index.js";
+let compiling = false;
+core.globalConfig.postProcessor = (inst) => {
+    if (compiling)
+        return;
+    const originalRun = inst._zod?.run;
+    if (typeof originalRun !== "function")
+        return;
+    const shim = (payload, ctx) => {
+        // Bypass the fast path for any non-forward / non-sync / check-skipping call. The runtime owns those contracts.
+        if (ctx?.async || ctx?.direction === "backward" || ctx?.skipChecks) {
+            return originalRun(payload, ctx);
+        }
+        compiling = true;
+        try {
+            // Respect the jitless config: it exists precisely so CSP/no-eval environments never reach `new Function`. Global mode must not bypass it (explicit z.compile calls remain an explicit opt-in).
+            if (core.globalConfig.jitless) {
+                inst._zod.run = originalRun;
+                return originalRun(payload, ctx);
+            }
+            // Strict: the shim owns its own fallback below, and a non-strict compile would hand back `inst` — whose run is this shim — and reinstall it on itself.
+            const compiled = compile(inst, { strict: true });
+            // Only the run wrapper. Copying the compiled parse/safeParse closures would make their fallback re-enter this instance and run user callbacks a third time.
+            inst._zod.run = compiled._zod.run;
+            inst._zod.bag.fallbackRun = compiled._zod.bag.fallbackRun;
+            inst._zod.bag.validator = compiled._zod.bag.validator;
+        }
+        catch {
+            // Permanent fallback for unsupported schemas.
+            inst._zod.run = originalRun;
+        }
+        finally {
+            compiling = false;
+        }
+        return inst._zod.run(payload, ctx);
+    };
+    // Expose the pre-shim runtime so `compile()` invoked elsewhere can unwrap past the shim and capture the source-of-truth runtime. Without this, a user calling `z.compile(s)` after global mode is enabled would capture the shim itself, which would feed the wrapper into itself on fallback.
+    shim.__originalRun = originalRun;
+    inst._zod.run = shim;
+};

package/node_modules/zod/index.cjs

@@ -26,8 +26,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.z = void 0;
+exports.default = exports.z = void 0;
 const z = __importStar(require("./v4/classic/external.cjs"));
 exports.z = z;
-__exportStar(require("./v4/classic/external.cjs"), exports);
 exports.default = z;
+__exportStar(require("./v4/classic/external.cjs"), exports);

package/node_modules/zod/index.d.cts

@@ -1,4 +1,3 @@
 import * as z from "./v4/classic/external.cjs";
 export * from "./v4/classic/external.cjs";
-export { z };
-export default z;
+export { z, z as default };

package/node_modules/zod/index.d.ts

@@ -1,4 +1,3 @@
 import * as z from "./v4/classic/external.js";
 export * from "./v4/classic/external.js";
-export { z };
-export default z;
+export { z, z as default };

package/node_modules/zod/index.js

@@ -1,4 +1,7 @@
 import * as z from "./v4/classic/external.js";
 export * from "./v4/classic/external.js";
-export { z };
-export default z;
+// Aliasing the binding, instead of `export default z`, keeps the default export a
+// re-export of `z` rather than a fresh namespace value. Rollup and Webpack can then
+// shake `import z from "zod"` as they already shake `import { z } from "zod"` — without
+// this they pull in every locale. See #6050.
+export { z, z as default };