@series-inc/stowkit-cli 0.6.23 → 0.6.35

package/dist/init.js

@@ -95,6 +95,7 @@ export async function initProject(projectDir, opts) {
     const stowkitIgnores = [
         '# StowKit',
         '*.stowcache',
+        '.stow-thumbnails/',
         'public/cdn-assets/',
         'Open Packer.bat',
         'open-packer.sh',
@@ -104,6 +105,16 @@ export async function initProject(projectDir, opts) {
         if (!existing.includes('*.stowcache')) {
             await fs.writeFile(gitignorePath, existing.trimEnd() + '\n\n' + stowkitIgnores + '\n');
         }
+        else {
+            // Existing project — ensure newer ignore entries are present
+            let updated = existing;
+            if (!existing.includes('.stow-thumbnails/')) {
+                updated = updated.trimEnd() + '\n.stow-thumbnails/\n';
+            }
+            if (updated !== existing) {
+                await fs.writeFile(gitignorePath, updated);
+            }
+        }
     }
     catch {
         await fs.writeFile(gitignorePath, stowkitIgnores + '\n');
@@ -118,35 +129,135 @@ export async function initProject(projectDir, opts) {
     console.log(`  Config:         .felicityproject`);
     console.log(`  AI skills:      .claude/skills/stowkit/SKILL.md, .cursor/rules/stowkit.mdc`);
     console.log(`  Launcher:       Open Packer.bat (Windows) / open-packer.sh (macOS/Linux)`);
+    // Add engine-specific gitignore entries
+    if (withEngine) {
+        const engineIgnores = [
+            '# Engine (generated by postinstall)',
+            'node_modules/',
+            'dist/',
+            'public/basis/',
+            'public/stowkit/',
+            'public/stowkit_reader.wasm',
+        ].join('\n');
+        try {
+            const existing = await fs.readFile(gitignorePath, 'utf-8');
+            if (!existing.includes('public/stowkit_reader.wasm')) {
+                await fs.writeFile(gitignorePath, existing.trimEnd() + '\n\n' + engineIgnores + '\n');
+            }
+        }
+        catch {
+            // gitignore should exist from earlier step, but handle gracefully
+        }
+    }
     // Install engine if selected
     if (withEngine) {
         await installEngine(absDir);
     }
     console.log('');
-    console.log('Drop your assets (PNG, JPG, FBX, WAV, etc.) into assets/');
-    console.log('Then run: stowkit build');
-    console.log('Or double-click "Open Packer.bat" to launch the packer GUI.');
+    if (withEngine) {
+        console.log('Ready to go! Run:');
+        console.log('  npm run dev');
+    }
+    else {
+        console.log('Drop your assets (PNG, JPG, FBX, WAV, etc.) into assets/');
+        console.log('Then run: stowkit build');
+        console.log('Or double-click "Open Packer.bat" to launch the packer GUI.');
+    }
+}
+async function copyTemplateFiles(templateDir, targetDir) {
+    const copied = [];
+    const entries = await fs.readdir(templateDir, { withFileTypes: true });
+    for (const entry of entries) {
+        const src = path.join(templateDir, entry.name);
+        const dest = path.join(targetDir, entry.name);
+        if (entry.isDirectory()) {
+            const sub = await copyTemplateFiles(src, dest);
+            copied.push(...sub);
+        }
+        else {
+            // Skip package.json — handled separately via merge logic
+            if (entry.name === 'package.json')
+                continue;
+            try {
+                await fs.access(dest);
+                // File exists — don't clobber
+            }
+            catch {
+                await fs.mkdir(path.dirname(dest), { recursive: true });
+                await fs.copyFile(src, dest);
+                copied.push(path.relative(targetDir, dest));
+            }
+        }
+    }
+    return copied;
+}
+async function mergePackageJson(templatePkgPath, targetDir) {
+    const templatePkg = JSON.parse(await fs.readFile(templatePkgPath, 'utf-8'));
+    const targetPkgPath = path.join(targetDir, 'package.json');
+    let targetPkg;
+    try {
+        targetPkg = JSON.parse(await fs.readFile(targetPkgPath, 'utf-8'));
+    }
+    catch {
+        // No existing package.json — use template as-is
+        templatePkg.name = path.basename(targetDir);
+        await fs.writeFile(targetPkgPath, JSON.stringify(templatePkg, null, 2) + '\n');
+        return;
+    }
+    // Merge scripts (don't overwrite existing scripts)
+    targetPkg.scripts = { ...templatePkg.scripts, ...targetPkg.scripts };
+    // Ensure postinstall includes copy-decoders
+    if (!targetPkg.scripts.postinstall?.includes('copy-decoders')) {
+        targetPkg.scripts.postinstall = templatePkg.scripts.postinstall;
+    }
+    // Merge dependencies
+    for (const depType of ['dependencies', 'devDependencies', 'peerDependencies']) {
+        if (templatePkg[depType]) {
+            targetPkg[depType] = { ...templatePkg[depType], ...(targetPkg[depType] ?? {}) };
+        }
+    }
+    // Ensure type: module
+    if (!targetPkg.type)
+        targetPkg.type = 'module';
+    await fs.writeFile(targetPkgPath, JSON.stringify(targetPkg, null, 2) + '\n');
 }
 async function installEngine(absDir) {
+    const thisDir = path.dirname(fileURLToPath(import.meta.url));
+    const templateDir = path.resolve(thisDir, '../templates/engine');
+    // Verify template directory exists
+    try {
+        await fs.access(templateDir);
+    }
+    catch {
+        console.error('Engine template not found. Please update @series-inc/stowkit-cli.');
+        return;
+    }
     console.log('');
-    console.log('Installing @series-inc/rundot-3d-engine and three...');
+    console.log('Setting up 3D engine project...');
+    // Copy template files (skip existing, skip package.json)
+    const copied = await copyTemplateFiles(templateDir, absDir);
+    if (copied.length > 0) {
+        console.log(`  Created: ${copied.join(', ')}`);
+    }
+    // Merge or create package.json
+    await mergePackageJson(path.join(templateDir, 'package.json'), absDir);
+    // Install dependencies
+    console.log('  Installing dependencies...');
     const { execSync } = await import('node:child_process');
     try {
-        execSync('npm install @series-inc/rundot-3d-engine three', {
+        execSync('npm install', {
             cwd: absDir,
             stdio: 'inherit',
         });
     }
     catch {
-        console.error('Failed to install engine packages. You can install manually:');
-        console.error('  npm install @series-inc/rundot-3d-engine three');
+        console.error('Failed to install dependencies. Run `npm install` manually.');
         return;
     }
+    // Copy engine skill files
     await copyEngineSkillFiles(absDir);
     console.log('');
-    console.log('  3D Engine installed:');
-    console.log('    @series-inc/rundot-3d-engine');
-    console.log('    three');
+    console.log('  3D Engine project ready!');
     console.log('  AI skills: .claude/skills/stowkit-engine/SKILL.md, .cursor/rules/stowkit-engine.mdc');
 }
 async function copySkillFiles(absDir) {

package/dist/publish.js

@@ -1,7 +1,8 @@
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { readProjectConfig, scanDirectory } from './node-fs.js';
-import { readAssetsPackage, initAssetsPackage, createEmptyRegistry, } from './assets-package.js';
+import { readAssetsPackage, initAssetsPackage, } from './assets-package.js';
+import { createFirestoreClient } from './firestore.js';
 import { createGCSClient } from './gcs.js';
 import { readStowmeta } from './app/stowmeta-io.js';
 // ─── Build full dependency graph from srcArtDir ──────────────────────────────
@@ -145,7 +146,7 @@ export async function publishPackage(projectDir, opts = {}) {
     const bucketUri = opts.bucket
         ?? pkg.bucket
         ?? process.env.STOWKIT_BUCKET
-        ?? 'gs://venus-shared-assets-test';
+        ?? 'gs://rungame-shared-assets-test';
     log(`Bucket: ${bucketUri}`);
     // Step 4: Scan srcArtDir
     const scan = await scanDirectory(project.srcArtDir);
@@ -252,29 +253,15 @@ export async function publishPackage(projectDir, opts = {}) {
     }
     // Step 7: Create GCS client and auth
     const emitProgress = opts.onProgress ?? (() => { });
-    const totalUploads = filesToUpload.length + Object.keys(thumbMap).length + 2; // +2 for assets-package.json and registry.json
+    const totalUploads = filesToUpload.length + Object.keys(thumbMap).length + 2; // +2 for assets-package.json and Firestore writes
     let totalDone = 0;
     log('Authenticating with GCS...');
     emitProgress({ phase: 'auth', done: 0, total: totalUploads, message: 'Authenticating with GCS...' });
     const gcs = await createGCSClient(projectDir, bucketUri);
-    // Step 8: Download current registry
-    log('Fetching registry...');
-    const registryResult = await gcs.downloadWithGeneration('registry.json');
-    let registry;
-    let generation;
-    if (registryResult) {
-        registry = JSON.parse(registryResult.data);
-        generation = registryResult.generation;
-        vlog(`Registry loaded (generation: ${generation})`);
-    }
-    else {
-        registry = createEmptyRegistry();
-        generation = null;
-        vlog('No existing registry — will create new one');
-    }
-    // Step 9: Check version not already published
-    const existingPkg = registry.packages[pkg.name];
-    if (existingPkg?.versions[pkg.version] && !opts.force) {
+    // Step 8: Create Firestore client and check version
+    const firestore = await createFirestoreClient(projectDir);
+    const existingVer = await firestore.getVersion(pkg.name, pkg.version);
+    if (existingVer && !opts.force) {
         throw new Error(`Version ${pkg.version} of "${pkg.name}" is already published. ` +
             `Bump the version in assets-package.json or use --force to overwrite.`);
     }
@@ -338,27 +325,17 @@ export async function publishPackage(projectDir, opts = {}) {
         }
         catch { /* file doesn't exist, try next */ }
     }
-    // Step 13: Update and upload registry
+    // Step 13: Write to Firestore
     log('Updating registry...');
-    if (!registry.packages[pkg.name]) {
-        registry.packages[pkg.name] = {
-            description: pkg.description,
-            author: pkg.author,
-            tags: pkg.tags ?? [],
-            latest: pkg.version,
-            versions: {},
-        };
-    }
-    const regPkg = registry.packages[pkg.name];
-    regPkg.versions[pkg.version] = versionEntry;
-    regPkg.latest = pkg.version;
-    regPkg.description = pkg.description;
-    regPkg.author = pkg.author;
-    regPkg.tags = pkg.tags ?? [];
-    if (packThumbnail)
-        regPkg.thumbnail = packThumbnail;
     emitProgress({ phase: 'registry', done: totalDone, total: totalUploads, message: 'Updating registry...' });
-    await gcs.uploadWithGeneration('registry.json', JSON.stringify(registry, null, 2), generation);
+    await firestore.setVersion(pkg.name, pkg.version, versionEntry);
+    await firestore.setPackage(pkg.name, {
+        description: pkg.description,
+        author: pkg.author,
+        tags: pkg.tags ?? [],
+        latest: pkg.version,
+        thumbnail: packThumbnail ?? null,
+    });
     totalDone++;
     emitProgress({ phase: 'registry', done: totalDone, total: totalUploads, message: 'Done' });
     log(`\nPublished ${pkg.name}@${pkg.version} successfully!`);

package/dist/server.js

@@ -55,6 +55,8 @@ function broadcast(msg) {
             ws.send(data);
     }
 }
+/** Tracks the most recent fire-and-forget processing promise so wait=true can join it. */
+let activeProcessingTask = null;
 /**
  * Single entry point for all processing orchestration.
  * - Skips materials (they don't need processing)
@@ -136,10 +138,15 @@ function queueProcessing(opts = {}) {
         }
         broadcast({ type: 'processing-complete' });
     })();
+    // Track the active task so wait=true callers can join in-flight processing
+    activeProcessingTask = task.finally(() => {
+        if (activeProcessingTask === task)
+            activeProcessingTask = null;
+    });
     if (opts.await)
-        return task;
+        return activeProcessingTask;
     // Fire-and-forget: log errors but don't block caller
-    task.catch(err => console.error('[server] queueProcessing error:', err));
+    activeProcessingTask.catch(err => console.error('[server] queueProcessing error:', err));
     return Promise.resolve();
 }
 // ─── Helpers ────────────────────────────────────────────────────────────────
@@ -1028,10 +1035,16 @@ async function handleRequest(req, res, staticApps) {
             json(res, { error: 'No project open' }, 400);
             return;
         }
-        // If wait=true, process all pending assets synchronously before building
+        // If wait=true, ensure all asset processing completes before building.
+        // First join any in-flight processing, then start a new run for any remaining pending assets.
         const body = await readBody(req).then(b => b ? JSON.parse(b) : {}).catch(() => ({}));
         const wait = body.wait === true || url.searchParams.get('wait') === 'true';
         if (wait) {
+            // Await any already-running background processing
+            if (activeProcessingTask) {
+                await activeProcessingTask;
+            }
+            // Pick up any assets that became pending after the previous run
             const pending = assets.filter(a => a.status === 'pending' || a.status === 'processing');
             if (pending.length > 0) {
                 await queueProcessing({ await: true });
@@ -1767,21 +1780,28 @@ 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: {} });
+            const { createFirestoreReader } = await import('./firestore.js');
+            const reader = createFirestoreReader();
+            const allPackages = await reader.listPackages();
+            const packages = {};
+            for (const { name, data: pkg } of allPackages) {
+                const versionKeys = await reader.listVersionKeys(name);
+                const versions = {};
+                for (const ver of versionKeys) {
+                    const versionDoc = await reader.getVersion(name, ver);
+                    if (versionDoc)
+                        versions[ver] = versionDoc;
                 }
-                else {
-                    json(res, { error: `Failed to fetch registry: ${fetchRes.status}` }, 502);
-                }
-                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);
@@ -1797,9 +1817,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);
@@ -1813,9 +1835,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) {
@@ -1827,22 +1851,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 ?? [],
             });
         }
@@ -1864,21 +1888,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;

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,15 +26,15 @@ 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;

package/dist/store.js

@@ -1,31 +1,21 @@
 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();
-}
+import { createFirestoreReader } from './firestore.js';
+const DEFAULT_BUCKET = 'rungame-shared-assets-test';
 // ─── 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);
+    }
+    for (const { name: pkgName, data: pkg } of packages) {
         const verStr = pkg.latest;
-        const ver = pkg.versions[verStr];
+        const ver = await firestore.getVersion(pkgName, verStr);
         if (!ver)
             continue;
         for (const asset of ver.assets) {
@@ -186,33 +176,36 @@ 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();
+    const results = [];
+    for (const { name, data: pkg } of packages) {
+        const ver = await firestore.getVersion(name, pkg.latest);
+        const versionKeys = await firestore.listVersionKeys(name);
         const thumbnailUrl = pkg.thumbnail
             ? `https://storage.googleapis.com/${bucket}/packages/${name}/${pkg.latest}/${pkg.thumbnail}`
             : undefined;
-        return {
+        results.push({
             name,
             description: pkg.description,
             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,
-        };
-    });
+        });
+    }
+    return results;
 }
 // ─── 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);
@@ -221,8 +214,9 @@ export function resolveAssetDeps(registry, packageName, stringIds, version) {
 }
 // ─── CLI Commands ────────────────────────────────────────────────────────────
 export async function storeSearch(query, opts) {
-    const registry = await fetchRegistry(opts?.bucket);
-    let results = searchAssets(registry, query, { type: opts?.type });
+    const bucket = (opts?.bucket ?? DEFAULT_BUCKET).replace(/^gs:\/\//, '').replace(/\/$/, '');
+    const firestore = createFirestoreReader();
+    let results = await searchAssets(firestore, bucket, query, { type: opts?.type });
     if (opts?.limit && opts.limit > 0)
         results = results.slice(0, opts.limit);
     if (opts?.json) {
@@ -244,8 +238,9 @@ export async function storeSearch(query, opts) {
     console.log('');
 }
 export async function storeList(opts) {
-    const registry = await fetchRegistry(opts?.bucket);
-    const packages = listPackages(registry);
+    const bucket = (opts?.bucket ?? DEFAULT_BUCKET).replace(/^gs:\/\//, '').replace(/\/$/, '');
+    const firestore = createFirestoreReader();
+    const packages = await listStorePackages(firestore, bucket);
     if (opts?.json) {
         console.log(JSON.stringify(packages, null, 2));
         return;
@@ -264,13 +259,15 @@ export async function storeList(opts) {
     console.log('');
 }
 export async function storeInfo(packageName, opts) {
-    const registry = await fetchRegistry(opts?.bucket);
-    const pkg = registry.packages[packageName];
+    const bucket = (opts?.bucket ?? DEFAULT_BUCKET).replace(/^gs:\/\//, '').replace(/\/$/, '');
+    const firestore = createFirestoreReader();
+    const pkg = await firestore.getPackage(packageName);
     if (!pkg) {
         console.error(`Package "${packageName}" not found.`);
         process.exit(1);
     }
-    const ver = pkg.versions[pkg.latest];
+    const ver = await firestore.getVersion(packageName, pkg.latest);
+    const versionKeys = await firestore.listVersionKeys(packageName);
     if (opts?.json) {
         console.log(JSON.stringify({
             name: packageName,
@@ -278,7 +275,7 @@ export async function storeInfo(packageName, opts) {
             author: pkg.author,
             tags: pkg.tags ?? [],
             latest: pkg.latest,
-            versions: Object.keys(pkg.versions),
+            versions: versionKeys,
             assets: ver?.assets ?? [],
         }, null, 2));
         return;
@@ -290,7 +287,7 @@ export async function storeInfo(packageName, opts) {
         console.log(`  Author: ${pkg.author}`);
     if (pkg.tags?.length)
         console.log(`  Tags: ${pkg.tags.join(', ')}`);
-    console.log(`  Versions: ${Object.keys(pkg.versions).join(', ')}`);
+    console.log(`  Versions: ${versionKeys.join(', ')}`);
     if (ver) {
         console.log(`\nAssets (${ver.assets.length}):\n`);
         for (const a of ver.assets) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@series-inc/stowkit-cli",
-  "version": "0.6.23",
+  "version": "0.6.35",
   "type": "module",
   "bin": {
     "stowkit": "./dist/cli.js"
@@ -10,7 +10,8 @@
   "files": [
     "dist",
     "skill.md",
-    "wasm"
+    "wasm",
+    "templates"
   ],
   "scripts": {
     "build": "tsc",

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>