@series-inc/stowkit-cli 0.6.34 → 0.6.36

package/dist/server.js

@@ -1608,6 +1608,15 @@ async function handleRequest(req, res, staticApps) {
         if (Object.prototype.hasOwnProperty.call(body, 'defaults')) {
             nextConfig.defaults = normalizeProjectDefaults(body.defaults);
         }
+        if (Object.prototype.hasOwnProperty.call(body, 'ai')) {
+            const aiBody = body.ai;
+            if (aiBody && typeof aiBody.geminiApiKey === 'string' && aiBody.geminiApiKey.trim()) {
+                nextConfig.ai = { geminiApiKey: aiBody.geminiApiKey.trim() };
+            }
+            else {
+                nextConfig.ai = undefined;
+            }
+        }
         const renamedPacks = Array.isArray(body.renamedPacks)
             ? body.renamedPacks.filter((rename) => typeof rename?.oldName === 'string'
                 && typeof rename?.newName === 'string'
@@ -1780,21 +1789,31 @@ async function handleRequest(req, res, staticApps) {
     // GET /api/asset-store/registry — fetch the public registry
     if (pathname === '/api/asset-store/registry' && req.method === 'GET') {
         try {
-            const bucketParam = url.searchParams.get('bucket') ?? 'venus-shared-assets-test';
-            const bucketName = bucketParam.replace(/^gs:\/\//, '').replace(/\/$/, '');
-            const registryUrl = `https://storage.googleapis.com/${bucketName}/registry.json?t=${Date.now()}`;
-            const fetchRes = await fetch(registryUrl);
-            if (!fetchRes.ok) {
-                if (fetchRes.status === 404) {
-                    json(res, { schemaVersion: 1, packages: {} });
-                }
-                else {
-                    json(res, { error: `Failed to fetch registry: ${fetchRes.status}` }, 502);
+            const { createFirestoreReader } = await import('./firestore.js');
+            const reader = createFirestoreReader();
+            const allPackages = await reader.listPackages();
+            // Fetch all version keys in parallel
+            const allVersionKeys = await Promise.all(allPackages.map(({ name }) => reader.listVersionKeys(name)));
+            // Fetch all version docs in parallel
+            const allVersionDocs = await Promise.all(allPackages.map(({ name }, i) => Promise.all(allVersionKeys[i].map(ver => reader.getVersion(name, ver).then(doc => ({ ver, doc }))))));
+            const packages = {};
+            for (let i = 0; i < allPackages.length; i++) {
+                const { name, data: pkg } = allPackages[i];
+                const versions = {};
+                for (const { ver, doc } of allVersionDocs[i]) {
+                    if (doc)
+                        versions[ver] = doc;
                 }
-                return;
+                packages[name] = {
+                    description: pkg.description,
+                    author: pkg.author,
+                    tags: pkg.tags ?? [],
+                    latest: pkg.latest,
+                    thumbnail: pkg.thumbnail,
+                    versions,
+                };
             }
-            const registry = await fetchRes.json();
-            json(res, registry);
+            json(res, { schemaVersion: 1, packages });
         }
         catch (err) {
             json(res, { error: err.message }, 500);
@@ -1810,9 +1829,11 @@ async function handleRequest(req, res, staticApps) {
             const bucketParam = url.searchParams.get('bucket') ?? undefined;
             const limitParam = url.searchParams.get('limit');
             const limit = limitParam ? parseInt(limitParam, 10) : undefined;
-            const { fetchRegistry, searchAssets } = await import('./store.js');
-            const registry = await fetchRegistry(bucketParam);
-            let results = searchAssets(registry, query, { type, package: pkg });
+            const { createFirestoreReader } = await import('./firestore.js');
+            const { searchAssets } = await import('./store.js');
+            const reader = createFirestoreReader();
+            const bucket = (bucketParam ?? 'rungame-shared-assets-test').replace(/^gs:\/\//, '').replace(/\/$/, '');
+            let results = await searchAssets(reader, bucket, query, { type, package: pkg });
             if (limit && limit > 0)
                 results = results.slice(0, limit);
             json(res, results);
@@ -1826,9 +1847,11 @@ async function handleRequest(req, res, staticApps) {
     if (pathname === '/api/asset-store/packages' && req.method === 'GET') {
         try {
             const bucketParam = url.searchParams.get('bucket') ?? undefined;
-            const { fetchRegistry, listPackages } = await import('./store.js');
-            const registry = await fetchRegistry(bucketParam);
-            const packages = listPackages(registry);
+            const { createFirestoreReader } = await import('./firestore.js');
+            const { listStorePackages } = await import('./store.js');
+            const reader = createFirestoreReader();
+            const bucket = (bucketParam ?? 'rungame-shared-assets-test').replace(/^gs:\/\//, '').replace(/\/$/, '');
+            const packages = await listStorePackages(reader, bucket);
             json(res, packages);
         }
         catch (err) {
@@ -1840,22 +1863,22 @@ async function handleRequest(req, res, staticApps) {
     if (pathname.startsWith('/api/asset-store/package/') && req.method === 'GET') {
         try {
             const packageName = decodeURIComponent(pathname.slice('/api/asset-store/package/'.length));
-            const bucketParam = url.searchParams.get('bucket') ?? undefined;
-            const { fetchRegistry } = await import('./store.js');
-            const registry = await fetchRegistry(bucketParam);
-            const pkg = registry.packages[packageName];
+            const { createFirestoreReader } = await import('./firestore.js');
+            const reader = createFirestoreReader();
+            const pkg = await reader.getPackage(packageName);
             if (!pkg) {
                 json(res, { error: `Package "${packageName}" not found` }, 404);
                 return;
             }
-            const ver = pkg.versions[pkg.latest];
+            const ver = await reader.getVersion(packageName, pkg.latest);
+            const versionKeys = await reader.listVersionKeys(packageName);
             json(res, {
                 name: packageName,
                 description: pkg.description,
                 author: pkg.author,
                 tags: pkg.tags ?? [],
                 latest: pkg.latest,
-                versions: Object.keys(pkg.versions),
+                versions: versionKeys,
                 assets: ver?.assets ?? [],
             });
         }
@@ -1877,21 +1900,17 @@ async function handleRequest(req, res, staticApps) {
                 json(res, { error: 'Missing packageName, version, or stringIds' }, 400);
                 return;
             }
-            const bucketName = (bucketParam ?? 'venus-shared-assets-test').replace(/^gs:\/\//, '').replace(/\/$/, '');
+            const bucketName = (bucketParam ?? 'rungame-shared-assets-test').replace(/^gs:\/\//, '').replace(/\/$/, '');
             const baseUrl = `https://storage.googleapis.com/${bucketName}`;
-            // Fetch registry to resolve deps
-            const regRes = await fetch(`${baseUrl}/registry.json`);
-            if (!regRes.ok) {
-                json(res, { error: 'Could not fetch registry' }, 502);
-                return;
-            }
-            const registry = await regRes.json();
-            const pkg = registry.packages[packageName];
+            // Resolve deps via Firestore
+            const { createFirestoreReader } = await import('./firestore.js');
+            const reader = createFirestoreReader();
+            const pkg = await reader.getPackage(packageName);
             if (!pkg) {
                 json(res, { error: `Package "${packageName}" not found` }, 404);
                 return;
             }
-            const ver = pkg.versions[version];
+            const ver = await reader.getVersion(packageName, version);
             if (!ver) {
                 json(res, { error: `Version "${version}" not found` }, 404);
                 return;
@@ -2004,6 +2023,179 @@ async function handleRequest(req, res, staticApps) {
         }
         return;
     }
+    // POST /api/ai/verify-key — validate a Gemini API key
+    if (pathname === '/api/ai/verify-key' && req.method === 'POST') {
+        try {
+            const body = JSON.parse(await readBody(req));
+            const apiKey = body.apiKey;
+            if (!apiKey || typeof apiKey !== 'string') {
+                json(res, { valid: false, error: 'Missing apiKey' });
+                return;
+            }
+            const { verifyApiKey } = await import('./ai-tagger.js');
+            const result = await verifyApiKey(apiKey);
+            json(res, result);
+        }
+        catch (err) {
+            json(res, { valid: false, error: err.message }, 500);
+        }
+        return;
+    }
+    // POST /api/ai/tag/:id — AI-tag a single asset
+    if (pathname.startsWith('/api/ai/tag/') && req.method === 'POST' && !pathname.endsWith('/tag-missing')) {
+        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/tag/'.length));
+        const asset = assets.find(a => a.id === id);
+        if (!asset) {
+            json(res, { error: 'Asset not found' }, 404);
+            return;
+        }
+        if (asset.type === AssetType.MaterialSchema) {
+            json(res, { error: 'Material schemas cannot be tagged' }, 400);
+            return;
+        }
+        try {
+            const { tagAsset: aiTagAsset } = await import('./ai-tagger.js');
+            let inputData;
+            let mimeType;
+            if (asset.type === AssetType.Audio) {
+                const ext = asset.fileName.split('.').pop()?.toLowerCase() ?? 'wav';
+                const mimeMap = {
+                    wav: 'audio/wav', mp3: 'audio/mpeg', ogg: 'audio/ogg',
+                    flac: 'audio/flac', aac: 'audio/aac', m4a: 'audio/mp4',
+                };
+                mimeType = mimeMap[ext] ?? 'audio/wav';
+                const raw = await readFile(projectConfig.srcArtDir, id);
+                if (!raw) {
+                    json(res, { error: 'Source audio file not found' }, 404);
+                    return;
+                }
+                inputData = Buffer.from(raw);
+            }
+            else {
+                const { readManifest, readThumbnailFile } = await import('./app/thumbnail-cache.js');
+                const manifest = await readManifest(projectConfig.srcArtDir);
+                const entry = manifest[asset.stringId];
+                if (!entry) {
+                    json(res, { error: 'No cached thumbnail — capture thumbnails first' }, 400);
+                    return;
+                }
+                const thumbData = await readThumbnailFile(projectConfig.srcArtDir, asset.stringId, entry.format);
+                if (!thumbData) {
+                    json(res, { error: 'Thumbnail file missing from cache' }, 400);
+                    return;
+                }
+                inputData = thumbData;
+                const formatMime = {
+                    png: 'image/png', webp: 'image/webp', webm: 'video/webm',
+                };
+                mimeType = formatMime[entry.format] ?? 'image/webp';
+            }
+            const newTags = await aiTagAsset(apiKey, asset.type, asset.fileName, inputData, mimeType);
+            const existingTags = asset.settings.tags ?? [];
+            const merged = [...new Set([...existingTags, ...newTags])];
+            asset.settings = { ...asset.settings, tags: merged };
+            if (!asset.parentId) {
+                const meta = assetSettingsToStowmeta(asset);
+                await writeStowmeta(projectConfig.srcArtDir, id, meta);
+            }
+            broadcast({ type: 'asset-update', id, updates: { settings: asset.settings } });
+            json(res, { tags: merged });
+        }
+        catch (err) {
+            json(res, { error: err.message }, 500);
+        }
+        return;
+    }
+    // POST /api/ai/tag-missing — bulk AI-tag all assets with empty tags
+    if (pathname === '/api/ai/tag-missing' && 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 { tagAsset: aiTagAsset } = await import('./ai-tagger.js');
+            const { readManifest, readThumbnailFile } = await import('./app/thumbnail-cache.js');
+            const manifest = await readManifest(projectConfig.srcArtDir);
+            const eligible = assets.filter(a => a.status === 'ready' &&
+                !a.settings.excluded &&
+                (!a.settings.tags || a.settings.tags.length === 0) &&
+                a.type !== AssetType.MaterialSchema &&
+                !a.parentId);
+            let tagged = 0;
+            let skipped = 0;
+            const errors = [];
+            for (const asset of eligible) {
+                try {
+                    let inputData;
+                    let mimeType;
+                    if (asset.type === AssetType.Audio) {
+                        const ext = asset.fileName.split('.').pop()?.toLowerCase() ?? 'wav';
+                        const mimeMap = {
+                            wav: 'audio/wav', mp3: 'audio/mpeg', ogg: 'audio/ogg',
+                            flac: 'audio/flac', aac: 'audio/aac', m4a: 'audio/mp4',
+                        };
+                        mimeType = mimeMap[ext] ?? 'audio/wav';
+                        const raw = await readFile(projectConfig.srcArtDir, asset.id);
+                        if (!raw) {
+                            skipped++;
+                            continue;
+                        }
+                        inputData = Buffer.from(raw);
+                    }
+                    else {
+                        const entry = manifest[asset.stringId];
+                        if (!entry) {
+                            skipped++;
+                            continue;
+                        }
+                        const thumbData = await readThumbnailFile(projectConfig.srcArtDir, asset.stringId, entry.format);
+                        if (!thumbData) {
+                            skipped++;
+                            continue;
+                        }
+                        inputData = thumbData;
+                        const formatMime = {
+                            png: 'image/png', webp: 'image/webp', webm: 'video/webm',
+                        };
+                        mimeType = formatMime[entry.format] ?? 'image/webp';
+                    }
+                    const tagPromise = aiTagAsset(apiKey, asset.type, asset.fileName, inputData, mimeType);
+                    const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('Gemini request timed out (30s)')), 30_000));
+                    const newTags = await Promise.race([tagPromise, timeoutPromise]);
+                    asset.settings = { ...asset.settings, tags: newTags };
+                    if (!asset.parentId) {
+                        const meta = assetSettingsToStowmeta(asset);
+                        await writeStowmeta(projectConfig.srcArtDir, asset.id, meta);
+                    }
+                    broadcast({ type: 'asset-update', id: asset.id, updates: { settings: asset.settings } });
+                    tagged++;
+                    await new Promise(r => setTimeout(r, 200));
+                }
+                catch (err) {
+                    errors.push({ id: asset.id, error: err.message });
+                }
+            }
+            json(res, { tagged, skipped, 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/dist/store.d.ts

@@ -1,5 +1,4 @@
-import type { Registry } from './assets-package.js';
-export declare function fetchRegistry(bucket?: string): Promise<Registry>;
+import type { FirestoreReader } from './firestore.js';
 export interface SearchResult {
     stringId: string;
     type: string;
@@ -27,26 +26,12 @@ export interface PackageInfo {
     /** Full URL to pack-level thumbnail, if uploaded */
     thumbnailUrl?: string;
 }
-export declare function searchAssets(registry: Registry, query: string, opts?: {
+export declare function searchAssets(firestore: FirestoreReader, bucket: string, query: string, opts?: {
     type?: string;
     package?: string;
-}): SearchResult[];
-export declare function listPackages(registry: Registry): PackageInfo[];
-export declare function resolveAssetDeps(registry: Registry, packageName: string, stringIds: string[], version?: string): {
+}): Promise<SearchResult[]>;
+export declare function listStorePackages(firestore: FirestoreReader, bucket: string): Promise<PackageInfo[]>;
+export declare function resolveAssetDeps(firestore: FirestoreReader, packageName: string, stringIds: string[], version?: string): Promise<{
     resolvedIds: string[];
     files: string[];
-};
-export declare function storeSearch(query: string, opts?: {
-    type?: string;
-    json?: boolean;
-    bucket?: string;
-    limit?: number;
-}): Promise<void>;
-export declare function storeList(opts?: {
-    json?: boolean;
-    bucket?: string;
-}): Promise<void>;
-export declare function storeInfo(packageName: string, opts?: {
-    json?: boolean;
-    bucket?: string;
-}): Promise<void>;
+}>;

package/dist/store.js

@@ -1,31 +1,22 @@
 import { resolveTransitiveDeps, resolveFiles } from './assets-package.js';
-const DEFAULT_BUCKET = 'venus-shared-assets-test';
-// ─── Fetch Registry ──────────────────────────────────────────────────────────
-export async function fetchRegistry(bucket) {
-    const bucketName = (bucket ?? DEFAULT_BUCKET).replace(/^gs:\/\//, '').replace(/\/$/, '');
-    const url = `https://storage.googleapis.com/${bucketName}/registry.json?t=${Date.now()}`;
-    const res = await fetch(url);
-    if (!res.ok) {
-        if (res.status === 404)
-            return { schemaVersion: 1, packages: {} };
-        throw new Error(`Failed to fetch registry: ${res.status}`);
-    }
-    return res.json();
-}
 // ─── Search ──────────────────────────────────────────────────────────────────
-export function searchAssets(registry, query, opts) {
+export async function searchAssets(firestore, bucket, query, opts) {
     // Support comma-separated terms: "coral, sea, ocean" matches any term
     const terms = query.split(',').map(t => t.toLowerCase().trim()).filter(Boolean);
     const scored = [];
-    const bucket = DEFAULT_BUCKET;
     // When searching within a specific package, skip package-level metadata
     // (name, description, tags) — it matches every asset and adds noise.
     const skipPkgMeta = !!opts?.package;
-    for (const [pkgName, pkg] of Object.entries(registry.packages)) {
-        if (opts?.package && pkgName !== opts.package)
-            continue;
+    let packages = await firestore.listPackages();
+    if (opts?.package) {
+        packages = packages.filter(p => p.name === opts.package);
+    }
+    // Fetch all latest versions in parallel
+    const versions = await Promise.all(packages.map(({ name, data: pkg }) => firestore.getVersion(name, pkg.latest)));
+    for (let i = 0; i < packages.length; i++) {
+        const { name: pkgName, data: pkg } = packages[i];
         const verStr = pkg.latest;
-        const ver = pkg.versions[verStr];
+        const ver = versions[i];
         if (!ver)
             continue;
         for (const asset of ver.assets) {
@@ -186,10 +177,16 @@ function scoreAsset(terms, asset, pkg, pkgName, skipPkgMeta = false) {
     return total;
 }
 // ─── List Packages ───────────────────────────────────────────────────────────
-export function listPackages(registry) {
-    const bucket = DEFAULT_BUCKET;
-    return Object.entries(registry.packages).map(([name, pkg]) => {
-        const ver = pkg.versions[pkg.latest];
+export async function listStorePackages(firestore, bucket) {
+    const packages = await firestore.listPackages();
+    // Fetch versions and version keys in parallel for all packages
+    const [versions, versionKeysList] = await Promise.all([
+        Promise.all(packages.map(({ name, data: pkg }) => firestore.getVersion(name, pkg.latest))),
+        Promise.all(packages.map(({ name }) => firestore.listVersionKeys(name))),
+    ]);
+    return packages.map(({ name, data: pkg }, i) => {
+        const ver = versions[i];
+        const versionKeys = versionKeysList[i];
         const thumbnailUrl = pkg.thumbnail
             ? `https://storage.googleapis.com/${bucket}/packages/${name}/${pkg.latest}/${pkg.thumbnail}`
             : undefined;
@@ -199,7 +196,7 @@ export function listPackages(registry) {
             author: pkg.author,
             tags: pkg.tags ?? [],
             latest: pkg.latest,
-            versions: Object.keys(pkg.versions),
+            versions: versionKeys,
             assetCount: ver?.assets.length ?? 0,
             totalSize: ver?.totalSize ?? 0,
             thumbnailUrl,
@@ -207,104 +204,15 @@ export function listPackages(registry) {
     });
 }
 // ─── Resolve Dependencies ────────────────────────────────────────────────────
-export function resolveAssetDeps(registry, packageName, stringIds, version) {
-    const pkg = registry.packages[packageName];
+export async function resolveAssetDeps(firestore, packageName, stringIds, version) {
+    const pkg = await firestore.getPackage(packageName);
     if (!pkg)
         throw new Error(`Package "${packageName}" not found`);
     const verStr = version ?? pkg.latest;
-    const ver = pkg.versions[verStr];
+    const ver = await firestore.getVersion(packageName, verStr);
     if (!ver)
         throw new Error(`Version "${verStr}" not found`);
     const resolvedIds = resolveTransitiveDeps(stringIds, ver.assets);
     const files = resolveFiles(resolvedIds, ver.assets);
     return { resolvedIds, files };
 }
-// ─── CLI Commands ────────────────────────────────────────────────────────────
-export async function storeSearch(query, opts) {
-    const registry = await fetchRegistry(opts?.bucket);
-    let results = searchAssets(registry, query, { type: opts?.type });
-    if (opts?.limit && opts.limit > 0)
-        results = results.slice(0, opts.limit);
-    if (opts?.json) {
-        console.log(JSON.stringify(results, null, 2));
-        return;
-    }
-    if (results.length === 0) {
-        console.log(`No assets found matching "${query}"`);
-        return;
-    }
-    console.log(`\nFound ${results.length} asset${results.length !== 1 ? 's' : ''} matching "${query}":\n`);
-    for (const r of results) {
-        const tags = r.tags.length > 0 ? ` [${r.tags.join(', ')}]` : '';
-        const deps = r.dependencies.length > 0 ? ` → ${r.dependencies.join(', ')}` : '';
-        const thumb = r.thumbnail ? ' (has thumbnail)' : '';
-        console.log(`  [${r.type}] ${r.stringId} — ${r.packageName}@${r.version}${tags}${deps}${thumb}`);
-        console.log(`    ${r.file} (${formatBytes(r.size)})`);
-    }
-    console.log('');
-}
-export async function storeList(opts) {
-    const registry = await fetchRegistry(opts?.bucket);
-    const packages = listPackages(registry);
-    if (opts?.json) {
-        console.log(JSON.stringify(packages, null, 2));
-        return;
-    }
-    if (packages.length === 0) {
-        console.log('No packages published yet.');
-        return;
-    }
-    console.log(`\n${packages.length} package${packages.length !== 1 ? 's' : ''} in the asset store:\n`);
-    for (const p of packages) {
-        const tags = p.tags.length > 0 ? ` [${p.tags.join(', ')}]` : '';
-        const desc = p.description ? ` — ${p.description}` : '';
-        console.log(`  ${p.name}@${p.latest}${desc}${tags}`);
-        console.log(`    ${p.assetCount} assets, ${formatBytes(p.totalSize)}, ${p.versions.length} version${p.versions.length !== 1 ? 's' : ''}`);
-    }
-    console.log('');
-}
-export async function storeInfo(packageName, opts) {
-    const registry = await fetchRegistry(opts?.bucket);
-    const pkg = registry.packages[packageName];
-    if (!pkg) {
-        console.error(`Package "${packageName}" not found.`);
-        process.exit(1);
-    }
-    const ver = pkg.versions[pkg.latest];
-    if (opts?.json) {
-        console.log(JSON.stringify({
-            name: packageName,
-            description: pkg.description,
-            author: pkg.author,
-            tags: pkg.tags ?? [],
-            latest: pkg.latest,
-            versions: Object.keys(pkg.versions),
-            assets: ver?.assets ?? [],
-        }, null, 2));
-        return;
-    }
-    console.log(`\n${packageName}@${pkg.latest}`);
-    if (pkg.description)
-        console.log(`  ${pkg.description}`);
-    if (pkg.author)
-        console.log(`  Author: ${pkg.author}`);
-    if (pkg.tags?.length)
-        console.log(`  Tags: ${pkg.tags.join(', ')}`);
-    console.log(`  Versions: ${Object.keys(pkg.versions).join(', ')}`);
-    if (ver) {
-        console.log(`\nAssets (${ver.assets.length}):\n`);
-        for (const a of ver.assets) {
-            const tags = a.tags.length > 0 ? ` [${a.tags.join(', ')}]` : '';
-            const deps = a.dependencies.length > 0 ? ` → ${a.dependencies.join(', ')}` : '';
-            console.log(`  [${a.type}] ${a.stringId}${tags}${deps} (${formatBytes(a.size)})`);
-        }
-    }
-    console.log('');
-}
-function formatBytes(bytes) {
-    if (bytes < 1024)
-        return `${bytes} B`;
-    if (bytes < 1024 * 1024)
-        return `${(bytes / 1024).toFixed(1)} KB`;
-    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@series-inc/stowkit-cli",
-  "version": "0.6.34",
+  "version": "0.6.36",
   "type": "module",
   "bin": {
     "stowkit": "./dist/cli.js"
@@ -10,18 +10,20 @@
   "files": [
     "dist",
     "skill.md",
-    "wasm"
+    "wasm",
+    "templates"
   ],
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch"
   },
   "dependencies": {
-    "@series-inc/stowkit-packer-gui": "^0.1.22",
+    "@google/genai": "^1.46.0",
     "@series-inc/stowkit-editor": "^0.1.8",
+    "@series-inc/stowkit-packer-gui": "^0.1.23",
+    "@strangeape/ffmpeg-audio-wasm": "^0.1.0",
     "draco3d": "^1.5.7",
     "fbx-parser": "^2.1.3",
-    "@strangeape/ffmpeg-audio-wasm": "^0.1.0",
     "sharp": "^0.33.5",
     "three": "^0.182.0",
     "ws": "^8.18.0"

package/templates/engine/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no" />
+    <title>My Game</title>
+  </head>
+  <body>
+    <canvas id="renderCanvas"></canvas>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>

package/templates/engine/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "my-stowkit-game",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "postinstall": "node scripts/copy-decoders.mjs",
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "@dimforge/rapier3d": "^0.11.2",
+    "@dimforge/rapier3d-compat": "^0.11.2",
+    "@series-inc/rundot-3d-engine": "^0.6.20",
+    "@series-inc/stowkit-three-loader": "^0.1.50",
+    "three": "^0.180.0",
+    "three-stdlib": "^2.36.0"
+  },
+  "peerDependencies": {
+    "@series-inc/rundot-game-sdk": "^5.5.4"
+  },
+  "devDependencies": {
+    "@series-inc/stowkit-reader": "^0.1.45",
+    "@types/node": "^20.11.16",
+    "@types/three": "^0.180.0",
+    "typescript": "^5.3.3",
+    "vite": "^5.0.12",
+    "vite-plugin-top-level-await": "^1.6.0",
+    "vite-plugin-wasm": "^3.5.0"
+  }
+}

package/templates/engine/prefabs/build.json

@@ -0,0 +1 @@
+{ "prefabs": [] }