@series-inc/stowkit-cli 0.6.40 → 0.6.41

package/dist/ai-tagger.d.ts

@@ -1,4 +1,14 @@
 import { AssetType } from './core/types.js';
+export interface SpriteSheetDetection {
+    isSpriteSheet: boolean;
+    rows?: number;
+    columns?: number;
+}
+/**
+ * Use Gemini Vision to detect whether an image is a sprite sheet.
+ * If it is, returns the detected row/column grid dimensions.
+ */
+export declare function detectSpriteSheet(apiKey: string, imageData: Buffer, mimeType: string): Promise<SpriteSheetDetection>;
 /**
  * Verify that a Gemini API key is valid by making a minimal request.
  */

package/dist/ai-tagger.js

@@ -1,6 +1,7 @@
 import { GoogleGenAI } from '@google/genai';
 import { AssetType } from './core/types.js';
-const MODEL = 'gemini-3.1-flash-lite-preview';
+const MODEL_LITE = 'gemini-3.1-flash-lite-preview';
+const MODEL_FLASH = 'gemini-3.1-pro-preview';
 const ASSET_TYPE_LABELS = {
     [AssetType.Texture2D]: 'texture',
     [AssetType.StaticMesh]: '3D mesh',
@@ -26,6 +27,65 @@ Rules:
 - no generic tags like asset, file, media, content
 - only include tags directly supported by the input`;
 }
+/**
+ * Use Gemini Vision to detect whether an image is a sprite sheet.
+ * If it is, returns the detected row/column grid dimensions.
+ */
+export async function detectSpriteSheet(apiKey, imageData, mimeType) {
+    const client = new GoogleGenAI({ apiKey });
+    const response = await client.models.generateContent({
+        model: MODEL_FLASH,
+        contents: [{
+                role: 'user',
+                parts: [
+                    {
+                        text: `Analyze this image and determine if it is a sprite sheet: a grid of multiple animation frames or game sprites arranged in regular rows and columns.
+
+If it IS a sprite sheet, count the rows and columns of the grid.
+If it is NOT a sprite sheet (e.g. a single image, photo, icon, or seamless texture), respond accordingly.
+
+Respond with ONLY a JSON object:
+- Sprite sheet: { "isSpriteSheet": true, "rows": <number>, "columns": <number> }
+- Not a sprite sheet: { "isSpriteSheet": false }`,
+                    },
+                    {
+                        inlineData: {
+                            data: imageData.toString('base64'),
+                            mimeType,
+                        },
+                    },
+                ],
+            }],
+        config: {
+            temperature: 0.1,
+            maxOutputTokens: 64,
+            responseMimeType: 'application/json',
+            responseSchema: {
+                type: 'OBJECT',
+                properties: {
+                    isSpriteSheet: { type: 'BOOLEAN' },
+                    rows: { type: 'INTEGER' },
+                    columns: { type: 'INTEGER' },
+                },
+                required: ['isSpriteSheet'],
+            },
+            safetySettings: [
+                { category: 'HARM_CATEGORY_HATE_SPEECH', threshold: 'OFF' },
+                { category: 'HARM_CATEGORY_DANGEROUS_CONTENT', threshold: 'OFF' },
+                { category: 'HARM_CATEGORY_SEXUALLY_EXPLICIT', threshold: 'OFF' },
+                { category: 'HARM_CATEGORY_HARASSMENT', threshold: 'OFF' },
+            ],
+        },
+    });
+    const text = response.text ?? '{}';
+    const parsed = JSON.parse(text);
+    return {
+        isSpriteSheet: !!parsed.isSpriteSheet,
+        rows: typeof parsed.rows === 'number' && parsed.rows > 0 ? parsed.rows : undefined,
+        columns: typeof parsed.columns === 'number' && parsed.columns > 0 ? parsed.columns : undefined,
+    };
+}
+// ─── API Key Verification ─────────────────────────────────────────────────────
 /**
  * Verify that a Gemini API key is valid by making a minimal request.
  */
@@ -33,7 +93,7 @@ export async function verifyApiKey(apiKey) {
     try {
         const client = new GoogleGenAI({ apiKey });
         const response = await client.models.generateContent({
-            model: MODEL,
+            model: MODEL_LITE,
             contents: [{ role: 'user', parts: [{ text: 'Respond with the word "ok"' }] }],
             config: { maxOutputTokens: 10 },
         });
@@ -51,7 +111,7 @@ export async function verifyApiKey(apiKey) {
 export async function tagAsset(apiKey, assetType, fileName, inputData, mimeType) {
     const client = new GoogleGenAI({ apiKey });
     const response = await client.models.generateContent({
-        model: MODEL,
+        model: MODEL_LITE,
         contents: [{
                 role: 'user',
                 parts: [

package/dist/cli.js

@@ -78,6 +78,7 @@ Usage:
   stowkit init [dir]              Initialize a StowKit project (interactive menu)
   stowkit init --with-engine      Initialize with 3D engine included
   stowkit init --no-engine        Initialize without 3D engine (skip prompt)
+  stowkit init --with-publish     Initialize with assets-package.json for publishing
   stowkit init --update [dir]     Update AI skill files to match installed CLI version
   stowkit build [dir]             Full build: scan + process + pack
   stowkit scan [dir]              Detect new assets, generate .stowmeta defaults
@@ -175,6 +176,7 @@ async function main() {
                     update: args.includes('--update'),
                     withEngine: args.includes('--with-engine'),
                     noEngine: args.includes('--no-engine'),
+                    withPublish: args.includes('--with-publish'),
                 });
                 break;
             case 'update': {

package/dist/init.d.ts

@@ -2,5 +2,6 @@ export interface InitOptions {
     update?: boolean;
     withEngine?: boolean;
     noEngine?: boolean;
+    withPublish?: boolean;
 }
 export declare function initProject(projectDir: string, opts?: InitOptions): Promise<void>;

package/dist/init.js

@@ -153,6 +153,12 @@ export async function initProject(projectDir, opts) {
     if (withEngine) {
         await installEngine(absDir);
     }
+    // Create assets-package.json for publishing
+    if (opts?.withPublish) {
+        const { initAssetsPackage } = await import('./assets-package.js');
+        await initAssetsPackage(absDir, { name: path.basename(absDir) });
+        console.log(`  Publish config: assets-package.json`);
+    }
     console.log('');
     if (withEngine) {
         console.log('Ready to go! Run:');

package/dist/server.js

@@ -1,6 +1,7 @@
 import * as http from 'node:http';
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
+import { exec } from 'node:child_process';
 import { WebSocketServer, WebSocket } from 'ws';
 import { AssetType } from './core/types.js';
 import { defaultAssetSettings } from './app/state.js';
@@ -564,6 +565,68 @@ async function readBinaryBody(req) {
         chunks.push(chunk);
     return Buffer.concat(chunks);
 }
+// ─── SpriteSheet grid detection ──────────────────────────────────────────────
+const COMMON_TILE_SIZES = [16, 32, 48, 64, 128];
+function detectSpriteGrid(width, height) {
+    const result = detectGridDimensions(width, height);
+    if (result)
+        return { ...result, frameCount: result.columns * result.rows };
+    // Absolute fallback: single frame
+    return { columns: 1, rows: 1, frameCount: 1 };
+}
+function detectGridDimensions(width, height) {
+    // 1. Try common square tile sizes (covers most character/monster/item sheets)
+    for (const tile of COMMON_TILE_SIZES) {
+        if (width % tile === 0 && height % tile === 0) {
+            return { columns: width / tile, rows: height / tile };
+        }
+    }
+    // 2. Square frames where frame_size = height (single-row FX sheets)
+    if (height < width && width % height === 0) {
+        return { columns: width / height, rows: 1 };
+    }
+    // 3. Near-square single-row: find frame width closest to height among width's divisors
+    if (height < 64 && width > height * 1.5) {
+        const match = findBestSingleRowCols(width, height);
+        if (match)
+            return { columns: match, rows: 1 };
+    }
+    // 4. Non-square common tile combos
+    for (const th of COMMON_TILE_SIZES) {
+        if (height % th === 0) {
+            const rows = height / th;
+            for (const tw of COMMON_TILE_SIZES) {
+                if (width % tw === 0)
+                    return { columns: width / tw, rows };
+            }
+        }
+    }
+    // 5. frame_width = 16 with non-standard height
+    if (width % 16 === 0)
+        return { columns: width / 16, rows: 1 };
+    // 6. Near-square fallback for any size
+    const cols = findBestSingleRowCols(width, height);
+    if (cols)
+        return { columns: cols, rows: 1 };
+    return null;
+}
+function findBestSingleRowCols(width, height) {
+    let bestCloseness = Infinity;
+    let bestCols = null;
+    for (let cols = 1; cols <= width; cols++) {
+        if (width % cols !== 0)
+            continue;
+        const fw = width / cols;
+        if (fw < height * 0.4 || fw > height * 2.5)
+            continue;
+        const closeness = Math.abs(fw / height - 1.0);
+        if (closeness < bestCloseness) {
+            bestCloseness = closeness;
+            bestCols = cols;
+        }
+    }
+    return bestCloseness < 0.6 ? bestCols : null;
+}
 function json(res, data, status = 200) {
     res.writeHead(status, {
         'Content-Type': 'application/json',
@@ -1456,6 +1519,34 @@ async function handleRequest(req, res, staticApps) {
         json(res, { ok: true, removedAssets: removedIds.length });
         return;
     }
+    // POST /api/reveal — open file or folder in OS file explorer
+    if (pathname === '/api/reveal' && req.method === 'POST') {
+        if (!projectConfig) {
+            json(res, { error: 'No project open' }, 400);
+            return;
+        }
+        const body = JSON.parse(await readBody(req));
+        const relativePath = body.path;
+        if (!relativePath) {
+            json(res, { error: 'Missing path' }, 400);
+            return;
+        }
+        const fullPath = path.resolve(projectConfig.srcArtDir, relativePath);
+        // Ensure the path is inside the project
+        if (!fullPath.startsWith(path.resolve(projectConfig.srcArtDir))) {
+            json(res, { error: 'Path outside project' }, 403);
+            return;
+        }
+        const stat = await fs.stat(fullPath).catch(() => null);
+        if (stat?.isDirectory()) {
+            exec(`explorer "${fullPath}"`);
+        }
+        else {
+            exec(`explorer /select,"${fullPath}"`);
+        }
+        json(res, { ok: true });
+        return;
+    }
     // GET /api/asset/:id/source — serve source file for preview
     if (pathname.startsWith('/api/asset/') && pathname.endsWith('/source') && req.method === 'GET') {
         const id = decodeURIComponent(pathname.slice('/api/asset/'.length, -'/source'.length));
@@ -1629,6 +1720,173 @@ async function handleRequest(req, res, staticApps) {
         json(res, { ok: true, asset });
         return;
     }
+    // POST /api/convert-to-spritesheet — auto-detect grid from a texture and create a .stowspritesheet
+    if (pathname === '/api/convert-to-spritesheet' && req.method === 'POST') {
+        if (!projectConfig) {
+            json(res, { error: 'No project open' }, 400);
+            return;
+        }
+        const body = JSON.parse(await readBody(req));
+        const textureId = body.textureId;
+        if (!textureId) {
+            json(res, { error: 'Missing textureId' }, 400);
+            return;
+        }
+        const textureAsset = assets.find(a => a.id === textureId);
+        if (!textureAsset || textureAsset.type !== AssetType.Texture2D) {
+            json(res, { error: 'Asset is not a texture' }, 400);
+            return;
+        }
+        // Use caller-supplied grid override, otherwise heuristic-detect from image dimensions
+        let rows;
+        let columns;
+        if (typeof body.rows === 'number' && body.rows > 0 && typeof body.columns === 'number' && body.columns > 0) {
+            rows = body.rows;
+            columns = body.columns;
+        }
+        else {
+            const dims = await probeImageDimensions(projectConfig.srcArtDir, textureId);
+            if (!dims) {
+                json(res, { error: 'Could not read image dimensions' }, 500);
+                return;
+            }
+            ({ rows, columns } = detectSpriteGrid(dims.width, dims.height));
+        }
+        const frameCount = rows * columns;
+        // Build name: foldername_imagename_animation
+        const parts = textureId.replace(/\\/g, '/').split('/');
+        const stem = parts[parts.length - 1].replace(/\.[^.]+$/, '').replace(/^SpriteSheet/, '').replace(/^spritesheet/i, '');
+        const folder = parts.length >= 2 ? parts[parts.length - 2] : '';
+        const safeName = [folder, stem].filter(Boolean).join('_').replace(/\s+/g, '_').toLowerCase();
+        const sheetName = `${safeName}_animation`;
+        const targetFolder = parts.slice(0, -1).join('/');
+        const baseName = `${sheetName}.stowspritesheet`;
+        const fileName = targetFolder ? `${targetFolder}/${baseName}` : baseName;
+        // Check if already exists
+        if (assets.find(a => a.id === fileName)) {
+            json(res, { error: `Spritesheet already exists: ${fileName}` }, 409);
+            return;
+        }
+        const settings = defaultAssetSettings();
+        settings.spritesheetConfig = {
+            textureAssetId: textureId,
+            rows,
+            columns,
+            frameCount,
+            frameRate: 12,
+        };
+        const asset = {
+            id: fileName,
+            fileName: sheetName,
+            stringId: fileName.replace(/\.[^.]+$/, '').toLowerCase(),
+            type: AssetType.SpriteSheet,
+            status: 'ready',
+            settings,
+            sourceSize: 0,
+            processedSize: 0,
+        };
+        assets.push(asset);
+        const stowSpriteSheet = spritesheetConfigToStowSpriteSheet(settings.spritesheetConfig);
+        await writeStowSpriteSheet(projectConfig.srcArtDir, fileName, stowSpriteSheet);
+        const meta = assetSettingsToStowmeta(asset);
+        await writeStowmeta(projectConfig.srcArtDir, fileName, meta);
+        broadcast({ type: 'refresh' });
+        json(res, { ok: true, asset });
+        return;
+    }
+    // POST /api/batch-convert-folder-name — find all folders matching a name and convert all textures under them to sprite sheets
+    if (pathname === '/api/batch-convert-folder-name' && req.method === 'POST') {
+        if (!projectConfig) {
+            json(res, { error: 'No project open' }, 400);
+            return;
+        }
+        const body = JSON.parse(await readBody(req));
+        const folderName = body.folderName;
+        if (!folderName) {
+            json(res, { error: 'Missing folderName' }, 400);
+            return;
+        }
+        // Find all folders that match the given name (case-insensitive)
+        const matchingFolders = folders.filter(f => {
+            const parts = f.replace(/\\/g, '/').split('/');
+            return parts[parts.length - 1].toLowerCase() === folderName.toLowerCase();
+        });
+        if (matchingFolders.length === 0) {
+            json(res, { error: `No folders found matching "${folderName}"` }, 404);
+            return;
+        }
+        // Find all Texture2D assets under any of the matching folders
+        const textureIds = [];
+        for (const folder of matchingFolders) {
+            const prefix = folder + '/';
+            for (const asset of assets) {
+                if (asset.type === AssetType.Texture2D && (asset.id.startsWith(prefix) || asset.id.replace(/\\/g, '/').startsWith(prefix))) {
+                    textureIds.push(asset.id);
+                }
+            }
+        }
+        if (textureIds.length === 0) {
+            json(res, { error: `No textures found under folders matching "${folderName}"` }, 404);
+            return;
+        }
+        // Convert each texture to a sprite sheet (reuse the same logic as convert-to-spritesheet)
+        let succeeded = 0;
+        let failed = 0;
+        const created = [];
+        for (const textureId of textureIds) {
+            const textureAsset = assets.find(a => a.id === textureId);
+            if (!textureAsset) {
+                failed++;
+                continue;
+            }
+            const dims = await probeImageDimensions(projectConfig.srcArtDir, textureId);
+            if (!dims) {
+                failed++;
+                continue;
+            }
+            const { columns, rows, frameCount } = detectSpriteGrid(dims.width, dims.height);
+            const parts = textureId.replace(/\\/g, '/').split('/');
+            const stem = parts[parts.length - 1].replace(/\.[^.]+$/, '').replace(/^SpriteSheet/, '').replace(/^spritesheet/i, '');
+            const folder = parts.length >= 2 ? parts[parts.length - 2] : '';
+            const safeName = [folder, stem].filter(Boolean).join('_').replace(/\s+/g, '_').toLowerCase();
+            const sheetName = `${safeName}_animation`;
+            const targetFolder = parts.slice(0, -1).join('/');
+            const baseName = `${sheetName}.stowspritesheet`;
+            const fileName = targetFolder ? `${targetFolder}/${baseName}` : baseName;
+            if (assets.find(a => a.id === fileName)) {
+                failed++;
+                continue;
+            }
+            const settings = defaultAssetSettings();
+            settings.spritesheetConfig = {
+                textureAssetId: textureId,
+                rows,
+                columns,
+                frameCount,
+                frameRate: 12,
+            };
+            const asset = {
+                id: fileName,
+                fileName: sheetName,
+                stringId: fileName.replace(/\.[^.]+$/, '').toLowerCase(),
+                type: AssetType.SpriteSheet,
+                status: 'ready',
+                settings,
+                sourceSize: 0,
+                processedSize: 0,
+            };
+            assets.push(asset);
+            const stowSpriteSheet = spritesheetConfigToStowSpriteSheet(settings.spritesheetConfig);
+            await writeStowSpriteSheet(projectConfig.srcArtDir, fileName, stowSpriteSheet);
+            const meta = assetSettingsToStowmeta(asset);
+            await writeStowmeta(projectConfig.srcArtDir, fileName, meta);
+            created.push(asset);
+            succeeded++;
+        }
+        broadcast({ type: 'refresh' });
+        json(res, { ok: true, succeeded, failed, matchingFolders, assets: created });
+        return;
+    }
     // POST /api/create-folder
     if (pathname === '/api/create-folder' && req.method === 'POST') {
         if (!projectConfig) {
@@ -2043,6 +2301,31 @@ async function handleRequest(req, res, staticApps) {
         }
         return;
     }
+    // POST /api/asset-store/package/:name/delist — remove package from registry (keeps GCS files)
+    if (pathname.startsWith('/api/asset-store/package/') && pathname.endsWith('/delist') && req.method === 'POST') {
+        if (!projectConfig) {
+            json(res, { error: 'No project open' }, 400);
+            return;
+        }
+        try {
+            const packageName = decodeURIComponent(pathname.slice('/api/asset-store/package/'.length, -'/delist'.length));
+            const { createFirestoreClient } = await import('./firestore.js');
+            const firestore = await createFirestoreClient(projectConfig.projectDir);
+            const pkg = await firestore.getPackage(packageName);
+            if (!pkg) {
+                json(res, { error: `Package "${packageName}" not found` }, 404);
+                return;
+            }
+            await firestore.deletePackage(packageName);
+            const { clearFirestoreCache } = await import('./firestore.js');
+            clearFirestoreCache();
+            json(res, { ok: true, packageName });
+        }
+        catch (err) {
+            json(res, { error: err.message }, 500);
+        }
+        return;
+    }
     // POST /api/publish — publish assets to GCS (SSE stream with progress)
     if (pathname === '/api/publish' && req.method === 'POST') {
         if (!projectConfig) {
@@ -2370,6 +2653,159 @@ async function handleRequest(req, res, staticApps) {
         }
         return;
     }
+    // POST /api/ai/guess-spritesheet-grid/:id — ask Gemini to count rows/columns on a texture without creating anything
+    if (pathname.startsWith('/api/ai/guess-spritesheet-grid/') && req.method === 'POST') {
+        if (!projectConfig) {
+            json(res, { error: 'No project open' }, 400);
+            return;
+        }
+        const apiKey = projectConfig.config.ai?.geminiApiKey;
+        if (!apiKey) {
+            json(res, { error: 'Gemini API key not configured' }, 400);
+            return;
+        }
+        const id = decodeURIComponent(pathname.slice('/api/ai/guess-spritesheet-grid/'.length));
+        const asset = assets.find(a => a.id === id);
+        if (!asset || asset.type !== AssetType.Texture2D) {
+            json(res, { error: 'Asset is not a texture' }, 404);
+            return;
+        }
+        try {
+            const raw = await readFile(projectConfig.srcArtDir, id);
+            if (!raw) {
+                json(res, { error: 'Source file not found' }, 404);
+                return;
+            }
+            const ext = id.split('.').pop()?.toLowerCase() ?? 'png';
+            const mimeMap = {
+                png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg', webp: 'image/webp', gif: 'image/gif',
+            };
+            const mimeType = mimeMap[ext] ?? 'image/png';
+            const { detectSpriteSheet: aiDetectSpriteSheet } = await import('./ai-tagger.js');
+            const detection = await aiDetectSpriteSheet(apiKey, Buffer.from(raw), mimeType);
+            if (detection.isSpriteSheet && detection.rows && detection.columns) {
+                json(res, { rows: detection.rows, columns: detection.columns });
+            }
+            else {
+                // Fall back to heuristic
+                const dims = await probeImageDimensions(projectConfig.srcArtDir, id);
+                const grid = dims ? detectSpriteGrid(dims.width, dims.height) : { rows: 1, columns: 1 };
+                json(res, { rows: grid.rows, columns: grid.columns });
+            }
+        }
+        catch (err) {
+            json(res, { error: err.message }, 500);
+        }
+        return;
+    }
+    // POST /api/ai/detect-spritesheet-batch — use Gemini to detect sprite sheets across multiple textures concurrently
+    if (pathname === '/api/ai/detect-spritesheet-batch' && req.method === 'POST') {
+        if (!projectConfig) {
+            json(res, { error: 'No project open' }, 400);
+            return;
+        }
+        const apiKey = projectConfig.config.ai?.geminiApiKey;
+        if (!apiKey) {
+            json(res, { error: 'Gemini API key not configured' }, 400);
+            return;
+        }
+        try {
+            const body = JSON.parse(await readBody(req));
+            const ids = body.ids;
+            if (!Array.isArray(ids) || ids.length === 0) {
+                json(res, { error: 'ids must be a non-empty array' }, 400);
+                return;
+            }
+            const { detectSpriteSheet: aiDetectSpriteSheet } = await import('./ai-tagger.js');
+            const mimeMap = {
+                png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg', webp: 'image/webp', gif: 'image/gif',
+            };
+            let created = 0;
+            let notSpriteSheet = 0;
+            let alreadyExists = 0;
+            const errors = [];
+            const results = await Promise.allSettled(ids.map(async (id) => {
+                const asset = assets.find(a => a.id === id);
+                if (!asset || asset.type !== AssetType.Texture2D)
+                    throw new Error('Not a texture');
+                const raw = await readFile(projectConfig.srcArtDir, id);
+                if (!raw)
+                    throw new Error(`Source file not found: ${id}`);
+                const ext = id.split('.').pop()?.toLowerCase() ?? 'png';
+                const mimeType = mimeMap[ext] ?? 'image/png';
+                const detection = await aiDetectSpriteSheet(apiKey, Buffer.from(raw), mimeType);
+                if (!detection.isSpriteSheet)
+                    return 'notSpriteSheet';
+                // Use AI-detected grid, falling back to heuristic
+                let rows;
+                let columns;
+                if (detection.rows && detection.columns) {
+                    rows = detection.rows;
+                    columns = detection.columns;
+                }
+                else {
+                    const dims = await probeImageDimensions(projectConfig.srcArtDir, id);
+                    if (!dims)
+                        throw new Error('Could not read image dimensions');
+                    const grid = detectSpriteGrid(dims.width, dims.height);
+                    rows = grid.rows;
+                    columns = grid.columns;
+                }
+                const frameCount = rows * columns;
+                const parts = id.replace(/\\/g, '/').split('/');
+                const stem = parts[parts.length - 1].replace(/\.[^.]+$/, '').replace(/^SpriteSheet/, '').replace(/^spritesheet/i, '');
+                const folder = parts.length >= 2 ? parts[parts.length - 2] : '';
+                const safeName = [folder, stem].filter(Boolean).join('_').replace(/\s+/g, '_').toLowerCase();
+                const sheetName = `${safeName}_animation`;
+                const targetFolder = parts.slice(0, -1).join('/');
+                const baseName = `${sheetName}.stowspritesheet`;
+                const fileName = targetFolder ? `${targetFolder}/${baseName}` : baseName;
+                if (assets.find(a => a.id === fileName))
+                    return 'alreadyExists';
+                const settings = defaultAssetSettings();
+                settings.spritesheetConfig = { textureAssetId: id, rows, columns, frameCount, frameRate: 12 };
+                const newAsset = {
+                    id: fileName,
+                    fileName: sheetName,
+                    stringId: fileName.replace(/\.[^.]+$/, '').toLowerCase(),
+                    type: AssetType.SpriteSheet,
+                    status: 'ready',
+                    settings,
+                    sourceSize: 0,
+                    processedSize: 0,
+                };
+                assets.push(newAsset);
+                const stowSpriteSheet = spritesheetConfigToStowSpriteSheet(settings.spritesheetConfig);
+                await writeStowSpriteSheet(projectConfig.srcArtDir, fileName, stowSpriteSheet);
+                const newMeta = assetSettingsToStowmeta(newAsset);
+                await writeStowmeta(projectConfig.srcArtDir, fileName, newMeta);
+                return 'created';
+            }));
+            for (let i = 0; i < results.length; i++) {
+                const r = results[i];
+                if (r.status === 'fulfilled') {
+                    if (r.value === 'created')
+                        created++;
+                    else if (r.value === 'notSpriteSheet')
+                        notSpriteSheet++;
+                    else if (r.value === 'alreadyExists')
+                        alreadyExists++;
+                }
+                else {
+                    const errMsg = r.reason?.message ?? String(r.reason);
+                    console.error(`[ai-detect-spritesheet] ${ids[i]}: ${errMsg}`);
+                    errors.push({ id: ids[i], error: errMsg });
+                }
+            }
+            if (created > 0)
+                broadcast({ type: 'refresh' });
+            json(res, { created, notSpriteSheet, alreadyExists, errors });
+        }
+        catch (err) {
+            json(res, { error: err.message }, 500);
+        }
+        return;
+    }
     // GET /api/thumbnails/cached — return which thumbnails are still valid in the cache
     if (pathname === '/api/thumbnails/cached' && req.method === 'GET') {
         if (!projectConfig) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@series-inc/stowkit-cli",
-  "version": "0.6.40",
+  "version": "0.6.41",
   "type": "module",
   "bin": {
     "stowkit": "./dist/cli.js"