@series-inc/stowkit-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,35 @@
+// Core types and constants
+export * from './core/types.js';
+export * from './core/constants.js';
+export * from './core/binary.js';
+export * from './core/path.js';
+// Format
+export { StowPacker } from './format/packer.js';
+export * from './format/metadata.js';
+// App layer
+export * from './app/disk-project.js';
+export { BlobStore } from './app/blob-store.js';
+export * from './app/state.js';
+export * from './app/stowmeta-io.js';
+export * from './app/stowmat-io.js';
+export * from './app/process-cache.js';
+// Node file I/O
+export * from './node-fs.js';
+// Encoders
+export * from './encoders/interfaces.js';
+export { NodeBasisEncoder } from './encoders/basis-encoder.js';
+export { NodeDracoEncoder, dracoPresetToSettings } from './encoders/draco-encoder.js';
+export { NodeAacEncoder, NodeAudioDecoder } from './encoders/aac-encoder.js';
+export { NodeFbxImporter } from './encoders/fbx-loader.js';
+export { SharpImageDecoder } from './encoders/image-decoder.js';
+export { buildSkinnedMeshData } from './encoders/skinned-mesh-builder.js';
+// Pipeline
+export { processAsset, buildPack, buildAnimationDataBlobsV2 } from './pipeline.js';
+// Orchestrator
+export { fullBuild, scanProject, showStatus } from './orchestrator.js';
+// Server
+export { startServer } from './server.js';
+// Init
+export { initProject } from './init.js';
+// Cleanup
+export { cleanupProject } from './cleanup.js';

package/dist/init.d.ts

@@ -0,0 +1 @@
+export declare function initProject(projectDir: string): Promise<void>;

package/dist/init.js

@@ -0,0 +1,73 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+export async function initProject(projectDir) {
+    const absDir = path.resolve(projectDir);
+    // Check if already initialized
+    const configPath = path.join(absDir, '.felicityproject');
+    try {
+        await fs.access(configPath);
+        console.log(`Project already initialized at ${absDir}`);
+        return;
+    }
+    catch {
+        // Does not exist — create it
+    }
+    // Create srcArtDir with .gitignore for cache files
+    const srcArtDir = 'assets';
+    await fs.mkdir(path.join(absDir, srcArtDir), { recursive: true });
+    const assetsGitignore = path.join(absDir, srcArtDir, '.gitignore');
+    try {
+        await fs.access(assetsGitignore);
+    }
+    catch {
+        await fs.writeFile(assetsGitignore, '*.stowcache\n');
+    }
+    // Create public/cdn-assets output dir
+    await fs.mkdir(path.join(absDir, 'public/cdn-assets'), { recursive: true });
+    // Write .felicityproject
+    const config = {
+        srcArtDir,
+        name: path.basename(absDir),
+        cdnAssetsPath: 'public/cdn-assets',
+        packs: [{ name: 'default' }],
+    };
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+    // Add stowkit artifacts to .gitignore
+    const gitignorePath = path.join(absDir, '.gitignore');
+    const stowkitIgnores = [
+        '# StowKit',
+        '*.stowcache',
+        'public/cdn-assets/',
+    ].join('\n');
+    try {
+        const existing = await fs.readFile(gitignorePath, 'utf-8');
+        if (!existing.includes('*.stowcache')) {
+            await fs.writeFile(gitignorePath, existing.trimEnd() + '\n\n' + stowkitIgnores + '\n');
+        }
+    }
+    catch {
+        await fs.writeFile(gitignorePath, stowkitIgnores + '\n');
+    }
+    // Copy Claude skill file
+    const skillDir = path.join(absDir, '.claude', 'skills');
+    await fs.mkdir(skillDir, { recursive: true });
+    const thisDir = path.dirname(fileURLToPath(import.meta.url));
+    const skillSrc = path.resolve(thisDir, '../skill.md');
+    const skillDst = path.join(skillDir, 'stowkit.md');
+    try {
+        const skillContent = await fs.readFile(skillSrc, 'utf-8');
+        await fs.writeFile(skillDst, skillContent);
+    }
+    catch {
+        // Skill file not found in package — skip silently
+    }
+    console.log(`Initialized StowKit project at ${absDir}`);
+    console.log(`  Source art dir: ${srcArtDir}/`);
+    console.log(`  Output dir:     public/cdn-assets/`);
+    console.log(`  Config:         .felicityproject`);
+    console.log(`  Claude skill:   .claude/skills/stowkit.md`);
+    console.log('');
+    console.log('Drop your assets (PNG, JPG, FBX, WAV, etc.) into assets/');
+    console.log('Then run: npx stowkit build');
+}

package/dist/node-fs.d.ts

@@ -0,0 +1,22 @@
+import type { FelicityProject, FileSnapshot } from './app/disk-project.js';
+export declare function readFile(basePath: string, relativePath: string): Promise<Uint8Array | null>;
+export declare function readTextFile(basePath: string, relativePath: string): Promise<string | null>;
+export declare function writeFile(basePath: string, relativePath: string, data: string | Uint8Array): Promise<void>;
+export declare function deleteFile(basePath: string, relativePath: string): Promise<void>;
+export declare function fileExists(basePath: string, relativePath: string): Promise<boolean>;
+export declare function getFileSnapshot(basePath: string, relativePath: string): Promise<FileSnapshot | null>;
+export interface ScanResult {
+    sourceFiles: FileSnapshot[];
+    metaFiles: FileSnapshot[];
+    matFiles: FileSnapshot[];
+    folders: string[];
+}
+export declare function scanDirectory(basePath: string): Promise<ScanResult>;
+export interface ProjectConfig {
+    projectDir: string;
+    srcArtDir: string;
+    config: FelicityProject;
+    projectName: string;
+}
+export declare function readProjectConfig(projectDir: string): Promise<ProjectConfig>;
+export declare function writeFelicityProject(projectDir: string, config: FelicityProject): Promise<void>;

package/dist/node-fs.js

@@ -0,0 +1,148 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+// ─── File I/O ────────────────────────────────────────────────────────────────
+export async function readFile(basePath, relativePath) {
+    try {
+        const fullPath = path.join(basePath, relativePath);
+        const buf = await fs.readFile(fullPath);
+        return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+    }
+    catch {
+        return null;
+    }
+}
+export async function readTextFile(basePath, relativePath) {
+    try {
+        const fullPath = path.join(basePath, relativePath);
+        return await fs.readFile(fullPath, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeFile(basePath, relativePath, data) {
+    const fullPath = path.join(basePath, relativePath);
+    await fs.mkdir(path.dirname(fullPath), { recursive: true });
+    await fs.writeFile(fullPath, data);
+}
+export async function deleteFile(basePath, relativePath) {
+    try {
+        const fullPath = path.join(basePath, relativePath);
+        await fs.unlink(fullPath);
+    }
+    catch {
+        // Ignore — file may not exist
+    }
+}
+export async function fileExists(basePath, relativePath) {
+    try {
+        await fs.access(path.join(basePath, relativePath));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function getFileSnapshot(basePath, relativePath) {
+    try {
+        const fullPath = path.join(basePath, relativePath);
+        const stat = await fs.stat(fullPath);
+        return {
+            relativePath,
+            size: stat.size,
+            lastModified: stat.mtimeMs,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+// ─── Directory Scanning ──────────────────────────────────────────────────────
+const SOURCE_EXTENSIONS = new Set([
+    'png', 'jpg', 'jpeg', 'bmp', 'tga', 'webp', 'gif',
+    'wav', 'mp3', 'ogg', 'flac', 'aac', 'm4a',
+    'fbx', 'obj', 'gltf', 'glb',
+]);
+function isSourceFile(name) {
+    const ext = name.split('.').pop()?.toLowerCase() ?? '';
+    return SOURCE_EXTENSIONS.has(ext);
+}
+function isMetaFile(name) {
+    return name.endsWith('.stowmeta');
+}
+function isMatFile(name) {
+    return name.endsWith('.stowmat');
+}
+export async function scanDirectory(basePath) {
+    const sourceFiles = [];
+    const metaFiles = [];
+    const matFiles = [];
+    const folders = [];
+    await walkDirectory(basePath, '', sourceFiles, metaFiles, matFiles, folders);
+    return { sourceFiles, metaFiles, matFiles, folders };
+}
+async function walkDirectory(basePath, prefix, sourceFiles, metaFiles, matFiles, folders) {
+    const dirPath = prefix ? path.join(basePath, prefix) : basePath;
+    let entries;
+    try {
+        entries = await fs.readdir(dirPath, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+        if (entry.isDirectory()) {
+            if (entry.name.startsWith('.'))
+                continue;
+            folders.push(relativePath);
+            await walkDirectory(basePath, relativePath, sourceFiles, metaFiles, matFiles, folders);
+        }
+        else if (entry.isFile()) {
+            const fullPath = path.join(basePath, relativePath);
+            let stat;
+            try {
+                stat = await fs.stat(fullPath);
+            }
+            catch {
+                continue;
+            }
+            const snapshot = {
+                relativePath,
+                size: stat.size,
+                lastModified: stat.mtimeMs,
+            };
+            if (isMetaFile(entry.name)) {
+                metaFiles.push(snapshot);
+            }
+            else if (isMatFile(entry.name)) {
+                matFiles.push(snapshot);
+            }
+            else if (isSourceFile(entry.name)) {
+                sourceFiles.push(snapshot);
+            }
+        }
+    }
+}
+export async function readProjectConfig(projectDir) {
+    const configPath = path.join(projectDir, '.felicityproject');
+    let configText;
+    try {
+        configText = await fs.readFile(configPath, 'utf-8');
+    }
+    catch {
+        throw new Error(`No .felicityproject found in ${projectDir}. ` +
+            `Create one with {"srcArtDir": "."} to use the directory as a project.`);
+    }
+    const config = JSON.parse(configText);
+    if (!config.srcArtDir) {
+        throw new Error('.felicityproject is missing "srcArtDir" field.');
+    }
+    const srcArtDir = path.resolve(projectDir, config.srcArtDir);
+    const projectName = config.name || path.basename(projectDir);
+    return { projectDir, srcArtDir, config, projectName };
+}
+export async function writeFelicityProject(projectDir, config) {
+    const configPath = path.join(projectDir, '.felicityproject');
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+}

package/dist/orchestrator.d.ts

@@ -0,0 +1,20 @@
+export interface BuildOptions {
+    force?: boolean;
+    verbose?: boolean;
+    maxConcurrent?: number;
+    wasmDir?: string;
+}
+export interface ScanReport {
+    projectName: string;
+    srcArtDir: string;
+    sourceFiles: number;
+    metaFiles: number;
+    matFiles: number;
+    newFiles: string[];
+    totalAssets: number;
+}
+export declare function scanProject(projectDir: string, opts?: {
+    verbose?: boolean;
+}): Promise<ScanReport>;
+export declare function fullBuild(projectDir: string, opts?: BuildOptions): Promise<void>;
+export declare function showStatus(projectDir: string): Promise<void>;

package/dist/orchestrator.js

@@ -0,0 +1,301 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { AssetType } from './core/types.js';
+import { cleanupProject } from './cleanup.js';
+import { defaultAssetSettings } from './app/state.js';
+import { BlobStore } from './app/blob-store.js';
+import { readProjectConfig, scanDirectory, readFile, getFileSnapshot, } from './node-fs.js';
+import { readStowmeta, writeStowmeta, stowmetaToAssetSettings, generateDefaultStowmeta, } from './app/stowmeta-io.js';
+import { readStowmat, stowmatToMaterialConfig } from './app/stowmat-io.js';
+import { readCacheBlobs, writeCacheBlobs, buildCacheStamp, isCacheValid, } from './app/process-cache.js';
+import { processAsset, buildPack } from './pipeline.js';
+// ─── Encoder initialization ────────────────────────────────────────────────
+import { NodeBasisEncoder } from './encoders/basis-encoder.js';
+import { NodeDracoEncoder } from './encoders/draco-encoder.js';
+import { NodeAacEncoder, NodeAudioDecoder } from './encoders/aac-encoder.js';
+import { NodeFbxImporter } from './encoders/fbx-loader.js';
+import { SharpImageDecoder } from './encoders/image-decoder.js';
+export async function scanProject(projectDir, opts) {
+    const config = await readProjectConfig(projectDir);
+    const scan = await scanDirectory(config.srcArtDir);
+    const verbose = opts?.verbose ?? false;
+    const existingMeta = new Set(scan.metaFiles.map(f => f.relativePath.replace(/\.stowmeta$/, '')));
+    const newFiles = [];
+    for (const file of scan.sourceFiles) {
+        if (!existingMeta.has(file.relativePath)) {
+            newFiles.push(file.relativePath);
+            const meta = generateDefaultStowmeta(file.relativePath);
+            await writeStowmeta(config.srcArtDir, file.relativePath, meta);
+            if (verbose)
+                console.log(`  [new] ${file.relativePath} → .stowmeta (${meta.type})`);
+        }
+    }
+    return {
+        projectName: config.projectName,
+        srcArtDir: config.srcArtDir,
+        sourceFiles: scan.sourceFiles.length,
+        metaFiles: scan.metaFiles.length,
+        matFiles: scan.matFiles.length,
+        newFiles,
+        totalAssets: scan.sourceFiles.length + scan.matFiles.length,
+    };
+}
+// ─── Full Build ──────────────────────────────────────────────────────────────
+export async function fullBuild(projectDir, opts) {
+    const verbose = opts?.verbose ?? false;
+    const force = opts?.force ?? false;
+    const maxConcurrent = opts?.maxConcurrent ?? 8;
+    const config = await readProjectConfig(projectDir);
+    if (verbose)
+        console.log(`Project: ${config.projectName}`);
+    if (verbose)
+        console.log(`Source dir: ${config.srcArtDir}`);
+    // 1. Scan
+    const scan = await scanDirectory(config.srcArtDir);
+    if (verbose)
+        console.log(`Found ${scan.sourceFiles.length} source files, ${scan.matFiles.length} materials`);
+    // 2. Build asset list
+    const assets = [];
+    const assetsById = new Map();
+    for (const file of scan.sourceFiles) {
+        const id = file.relativePath;
+        let meta = await readStowmeta(config.srcArtDir, id);
+        if (!meta) {
+            meta = generateDefaultStowmeta(id);
+            await writeStowmeta(config.srcArtDir, id, meta);
+        }
+        const { type, settings } = stowmetaToAssetSettings(meta);
+        const fileName = id.split('/').pop() ?? id;
+        const asset = {
+            id,
+            fileName,
+            stringId: meta.stringId,
+            type,
+            status: 'pending',
+            settings,
+            sourceSize: file.size,
+            processedSize: 0,
+        };
+        // Check cache
+        if (!force && meta.cache) {
+            const snapshot = await getFileSnapshot(config.srcArtDir, id);
+            if (snapshot && isCacheValid(meta, snapshot, type, settings)) {
+                const cached = await readCacheBlobs(config.srcArtDir, id);
+                if (cached) {
+                    for (const [key, data] of cached) {
+                        if (key === `${id}:__metadata__`) {
+                            try {
+                                asset.metadata = JSON.parse(new TextDecoder().decode(data));
+                            }
+                            catch { /* skip */ }
+                        }
+                        else {
+                            BlobStore.setProcessed(key, data);
+                        }
+                    }
+                    asset.status = 'ready';
+                    asset.processedSize = BlobStore.getProcessed(id)?.length ?? 0;
+                    if (verbose)
+                        console.log(`  [cached] ${id}`);
+                }
+            }
+        }
+        assets.push(asset);
+        assetsById.set(id, asset);
+    }
+    // Materials from .stowmat files
+    for (const matFile of scan.matFiles) {
+        const id = matFile.relativePath;
+        const mat = await readStowmat(config.srcArtDir, id);
+        if (!mat)
+            continue;
+        const materialConfig = stowmatToMaterialConfig(mat);
+        const fileName = id.split('/').pop() ?? id;
+        const baseName = fileName.replace(/\.[^.]+$/, '');
+        let meta = await readStowmeta(config.srcArtDir, id);
+        if (!meta) {
+            meta = generateDefaultStowmeta(id, AssetType.MaterialSchema);
+            await writeStowmeta(config.srcArtDir, id, meta);
+        }
+        const asset = {
+            id,
+            fileName,
+            stringId: meta.stringId || baseName,
+            type: AssetType.MaterialSchema,
+            status: 'ready',
+            settings: { ...defaultAssetSettings(), materialConfig, pack: meta.pack ?? 'default', tags: meta.tags ?? [] },
+            sourceSize: matFile.size,
+            processedSize: 0,
+        };
+        assets.push(asset);
+        assetsById.set(id, asset);
+    }
+    // 3. Process stale assets
+    const pending = assets.filter(a => a.status === 'pending');
+    if (pending.length === 0) {
+        if (verbose)
+            console.log('All assets cached, nothing to process.');
+    }
+    else {
+        console.log(`Processing ${pending.length} asset(s)...`);
+        // Initialize encoders
+        const ctx = await initializeEncoders(opts?.wasmDir);
+        // Process with concurrency limit
+        let processed = 0;
+        const queue = [...pending];
+        async function processNext() {
+            while (queue.length > 0) {
+                const asset = queue.shift();
+                const id = asset.id;
+                try {
+                    // Load source
+                    const sourceData = await readFile(config.srcArtDir, id);
+                    if (!sourceData)
+                        throw new Error(`Could not read source file: ${id}`);
+                    BlobStore.setSource(id, sourceData);
+                    const t0 = performance.now();
+                    const result = await processAsset(id, sourceData, asset.type, asset.stringId, asset.settings, ctx);
+                    const elapsed = (performance.now() - t0).toFixed(0);
+                    asset.status = 'ready';
+                    asset.metadata = result.metadata;
+                    asset.processedSize = result.processedSize;
+                    processed++;
+                    console.log(`  [${processed}/${pending.length}] ${id} (${elapsed}ms)`);
+                    // Write cache
+                    const cacheEntries = new Map();
+                    const processedBlob = BlobStore.getProcessed(id);
+                    if (processedBlob)
+                        cacheEntries.set(id, processedBlob);
+                    if (result.metadata) {
+                        cacheEntries.set(`${id}:__metadata__`, new TextEncoder().encode(JSON.stringify(result.metadata)));
+                    }
+                    // Auxiliary blobs
+                    for (const suffix of [':skinnedMeta', ':animMeta', ':animCount']) {
+                        const blob = BlobStore.getProcessed(`${id}${suffix}`);
+                        if (blob)
+                            cacheEntries.set(`${id}${suffix}`, blob);
+                    }
+                    const animCountBlob = BlobStore.getProcessed(`${id}:animCount`);
+                    const clipCount = animCountBlob ? animCountBlob[0] : 0;
+                    for (let ci = 0; ci < clipCount; ci++) {
+                        const animData = BlobStore.getProcessed(`${id}:anim:${ci}`);
+                        if (animData)
+                            cacheEntries.set(`${id}:anim:${ci}`, animData);
+                        const animMeta = BlobStore.getProcessed(`${id}:animMeta:${ci}`);
+                        if (animMeta)
+                            cacheEntries.set(`${id}:animMeta:${ci}`, animMeta);
+                    }
+                    if (cacheEntries.size > 0) {
+                        await writeCacheBlobs(config.srcArtDir, id, cacheEntries);
+                        // Stamp cache in .stowmeta
+                        const snapshot = await getFileSnapshot(config.srcArtDir, id);
+                        if (snapshot) {
+                            const meta = await readStowmeta(config.srcArtDir, id);
+                            if (meta) {
+                                meta.cache = buildCacheStamp(snapshot, asset.type, asset.settings);
+                                await writeStowmeta(config.srcArtDir, id, meta);
+                            }
+                        }
+                    }
+                }
+                catch (err) {
+                    asset.status = 'error';
+                    asset.error = err instanceof Error ? err.message : String(err);
+                    processed++;
+                    console.error(`  [${processed}/${pending.length}] ${id} FAILED: ${asset.error}`);
+                }
+            }
+        }
+        const workers = [];
+        for (let i = 0; i < Math.min(maxConcurrent, pending.length); i++) {
+            workers.push(processNext());
+        }
+        await Promise.all(workers);
+    }
+    // 4. Clean orphaned caches/metas
+    await cleanupProject(config.projectDir, { verbose });
+    // 5. Build packs
+    const packs = config.config.packs ?? [{ name: 'default' }];
+    const cdnDir = path.resolve(config.projectDir, config.config.cdnAssetsPath ?? 'public/cdn-assets');
+    await fs.mkdir(cdnDir, { recursive: true });
+    for (const pack of packs) {
+        const packAssets = assets.filter(a => a.status === 'ready' &&
+            (a.settings.pack === pack.name || (!a.settings.pack && pack.name === 'default')));
+        if (packAssets.length === 0) {
+            if (verbose)
+                console.log(`Pack "${pack.name}": no assets, skipping`);
+            continue;
+        }
+        console.log(`Building pack "${pack.name}" (${packAssets.length} assets)...`);
+        const packData = buildPack(packAssets, assetsById);
+        const outPath = path.join(cdnDir, `${pack.name}.stow`);
+        await fs.writeFile(outPath, packData);
+        console.log(`  → ${outPath} (${(packData.length / 1024).toFixed(0)} KB)`);
+    }
+    // Summary
+    const errors = assets.filter(a => a.status === 'error');
+    if (errors.length > 0) {
+        console.log(`\n${errors.length} asset(s) failed:`);
+        for (const e of errors)
+            console.log(`  ${e.id}: ${e.error}`);
+    }
+    console.log('Build complete.');
+}
+// ─── Status ──────────────────────────────────────────────────────────────────
+export async function showStatus(projectDir) {
+    const config = await readProjectConfig(projectDir);
+    const scan = await scanDirectory(config.srcArtDir);
+    console.log(`Project: ${config.projectName}`);
+    console.log(`Source dir: ${config.srcArtDir}`);
+    console.log(`Source files: ${scan.sourceFiles.length}`);
+    console.log(`Material files: ${scan.matFiles.length}`);
+    console.log(`Meta files: ${scan.metaFiles.length}`);
+    const packs = config.config.packs ?? [{ name: 'default' }];
+    console.log(`Packs: ${packs.map(p => p.name).join(', ')}`);
+    // Count stale
+    let cached = 0;
+    let stale = 0;
+    for (const file of scan.sourceFiles) {
+        const meta = await readStowmeta(config.srcArtDir, file.relativePath);
+        if (!meta) {
+            stale++;
+            continue;
+        }
+        const { type, settings } = stowmetaToAssetSettings(meta);
+        if (meta.cache && isCacheValid(meta, file, type, settings)) {
+            cached++;
+        }
+        else {
+            stale++;
+        }
+    }
+    console.log(`Cached: ${cached}, Needs processing: ${stale}`);
+}
+// ─── Initialize Encoders ────────────────────────────────────────────────────
+async function initializeEncoders(wasmDir) {
+    const textureEncoder = new NodeBasisEncoder(wasmDir);
+    const meshEncoder = new NodeDracoEncoder();
+    const aacEncoder = new NodeAacEncoder();
+    const audioDecoder = new NodeAudioDecoder();
+    const meshImporter = new NodeFbxImporter();
+    const imageDecoder = new SharpImageDecoder();
+    await Promise.all([
+        textureEncoder.initialize(),
+        meshEncoder.initialize(),
+        aacEncoder.initialize(),
+        audioDecoder.initialize(),
+    ]);
+    return {
+        textureEncoder,
+        meshEncoder,
+        meshImporter,
+        imageDecoder,
+        audioDecoder,
+        aacEncoder,
+        onProgress: (id, msg) => {
+            // Simple console progress
+            const name = id.split('/').pop() ?? id;
+            process.stdout.write(`    [${name}] ${msg}\r`);
+        },
+    };
+}

package/dist/pipeline.d.ts

@@ -0,0 +1,23 @@
+import { AssetType } from './core/types.js';
+import type { AnimationClipMetadata } from './core/types.js';
+import type { AssetSettings, ProjectAsset } from './app/state.js';
+import type { ITextureEncoder, IMeshEncoder, IMeshImporter, IImageDecoder, IAudioDecoder, IAacEncoder, ImportedMesh } from './encoders/interfaces.js';
+export interface ProcessingContext {
+    textureEncoder: ITextureEncoder;
+    meshEncoder: IMeshEncoder;
+    meshImporter: IMeshImporter;
+    imageDecoder: IImageDecoder;
+    audioDecoder: IAudioDecoder;
+    aacEncoder: IAacEncoder;
+    onProgress?: (id: string, msg: string) => void;
+}
+export interface ProcessResult {
+    metadata?: ProjectAsset['metadata'];
+    processedSize: number;
+}
+export declare function processAsset(id: string, sourceData: Uint8Array, type: AssetType, stringId: string, settings: AssetSettings, ctx: ProcessingContext): Promise<ProcessResult>;
+export declare function buildPack(assets: ProjectAsset[], assetsById: Map<string, ProjectAsset>): Uint8Array;
+export declare function buildAnimationDataBlobsV2(imported: ImportedMesh): {
+    data: Uint8Array;
+    metadata: AnimationClipMetadata;
+}[];