@series-inc/stowkit-cli 0.1.0

package/dist/app/blob-store.d.ts

@@ -0,0 +1,9 @@
+export declare const BlobStore: {
+    setSource(id: string, data: Uint8Array): void;
+    getSource(id: string): Uint8Array | undefined;
+    setProcessed(id: string, data: Uint8Array): void;
+    getProcessed(id: string): Uint8Array | undefined;
+    remove(id: string): void;
+    renameAll(oldId: string, newId: string): void;
+    clear(): void;
+};

package/dist/app/blob-store.js

@@ -0,0 +1,42 @@
+const sourceBlobs = new Map();
+const processedBlobs = new Map();
+export const BlobStore = {
+    setSource(id, data) {
+        sourceBlobs.set(id, data);
+    },
+    getSource(id) {
+        return sourceBlobs.get(id);
+    },
+    setProcessed(id, data) {
+        processedBlobs.set(id, data);
+    },
+    getProcessed(id) {
+        return processedBlobs.get(id);
+    },
+    remove(id) {
+        sourceBlobs.delete(id);
+        processedBlobs.delete(id);
+    },
+    renameAll(oldId, newId) {
+        const prefix = `${oldId}:`;
+        for (const store of [sourceBlobs, processedBlobs]) {
+            const moves = [];
+            for (const [key, data] of store) {
+                if (key === oldId) {
+                    moves.push([key, newId, data]);
+                }
+                else if (key.startsWith(prefix)) {
+                    moves.push([key, `${newId}${key.slice(oldId.length)}`, data]);
+                }
+            }
+            for (const [oldKey, newKey, data] of moves) {
+                store.delete(oldKey);
+                store.set(newKey, data);
+            }
+        }
+    },
+    clear() {
+        sourceBlobs.clear();
+        processedBlobs.clear();
+    },
+};

package/dist/app/disk-project.d.ts

@@ -0,0 +1,84 @@
+import type { KTX2Quality, TextureResize, DracoQualityPreset, AacQuality, AudioSampleRate, MaterialFieldType, PreviewPropertyFlag } from '../core/types.js';
+export interface PackConfig {
+    name: string;
+}
+export interface FelicityProject {
+    srcArtDir: string;
+    name?: string;
+    cdnAssetsPath?: string;
+    prefabsPath?: string;
+    packs?: PackConfig[];
+}
+export interface FileSnapshot {
+    relativePath: string;
+    size: number;
+    lastModified: number;
+}
+export interface StowMetaCache {
+    sourceSize: number;
+    sourceLastModified: number;
+    settingsHash: string;
+}
+interface StowMetaBase {
+    version: 1;
+    type: string;
+    stringId: string;
+    tags: string[];
+    pack?: string;
+    cache?: StowMetaCache;
+}
+export interface StowMetaTexture extends StowMetaBase {
+    type: 'texture';
+    quality: string;
+    resize: string;
+    generateMipmaps: boolean;
+}
+export interface StowMetaAudio extends StowMetaBase {
+    type: 'audio';
+    aacQuality: string;
+    sampleRate: string;
+}
+export interface StowMetaStaticMesh extends StowMetaBase {
+    type: 'staticMesh';
+    dracoQuality: string;
+    materialOverrides: Record<string, string | null>;
+}
+export interface StowMetaSkinnedMesh extends StowMetaBase {
+    type: 'skinnedMesh';
+    materialOverrides: Record<string, string | null>;
+}
+export interface StowMetaAnimationClip extends StowMetaBase {
+    type: 'animationClip';
+    targetMeshId: string | null;
+}
+export interface StowMetaMaterialSchema extends StowMetaBase {
+    type: 'materialSchema';
+}
+export type StowMeta = StowMetaTexture | StowMetaAudio | StowMetaStaticMesh | StowMetaSkinnedMesh | StowMetaAnimationClip | StowMetaMaterialSchema;
+export interface StowMatProperty {
+    fieldName: string;
+    fieldType: string;
+    previewFlag: string;
+    value: [number, number, number, number];
+    textureAsset: string | null;
+}
+export interface StowMat {
+    version: 1;
+    schemaName: string;
+    properties: StowMatProperty[];
+}
+export declare const KTX2_QUALITY_STRINGS: Record<string, KTX2Quality>;
+export declare const KTX2_QUALITY_TO_STRING: Record<number, string>;
+export declare const TEXTURE_RESIZE_STRINGS: Record<string, TextureResize>;
+export declare const TEXTURE_RESIZE_TO_STRING: Record<number, string>;
+export declare const DRACO_QUALITY_STRINGS: Record<string, DracoQualityPreset>;
+export declare const DRACO_QUALITY_TO_STRING: Record<number, string>;
+export declare const AAC_QUALITY_STRINGS: Record<string, AacQuality>;
+export declare const AAC_QUALITY_TO_STRING: Record<number, string>;
+export declare const AUDIO_SAMPLE_RATE_STRINGS: Record<string, AudioSampleRate>;
+export declare const AUDIO_SAMPLE_RATE_TO_STRING: Record<number, string>;
+export declare const MATERIAL_FIELD_TYPE_STRINGS: Record<string, MaterialFieldType>;
+export declare const MATERIAL_FIELD_TYPE_TO_STRING: Record<number, string>;
+export declare const PREVIEW_FLAG_STRINGS: Record<string, PreviewPropertyFlag>;
+export declare const PREVIEW_FLAG_TO_STRING: Record<number, string>;
+export {};

package/dist/app/disk-project.js

@@ -0,0 +1,70 @@
+// ─── Enum String Mapping ─────────────────────────────────────────────────────
+export const KTX2_QUALITY_STRINGS = {
+    fastest: 0,
+    fast: 1,
+    normal: 2,
+    high: 3,
+    best: 4,
+};
+export const KTX2_QUALITY_TO_STRING = {
+    0: 'fastest', 1: 'fast', 2: 'normal', 3: 'high', 4: 'best',
+};
+export const TEXTURE_RESIZE_STRINGS = {
+    full: 0,
+    half: 1,
+    quarter: 2,
+    eighth: 3,
+};
+export const TEXTURE_RESIZE_TO_STRING = {
+    0: 'full', 1: 'half', 2: 'quarter', 3: 'eighth',
+};
+export const DRACO_QUALITY_STRINGS = {
+    fast: 0,
+    balanced: 1,
+    high: 2,
+    maximum: 3,
+};
+export const DRACO_QUALITY_TO_STRING = {
+    0: 'fast', 1: 'balanced', 2: 'high', 3: 'maximum',
+};
+export const AAC_QUALITY_STRINGS = {
+    lowest: 0,
+    low: 1,
+    medium: 2,
+    high: 3,
+    best: 4,
+};
+export const AAC_QUALITY_TO_STRING = {
+    0: 'lowest', 1: 'low', 2: 'medium', 3: 'high', 4: 'best',
+};
+export const AUDIO_SAMPLE_RATE_STRINGS = {
+    auto: 0,
+    '48000': 48000,
+    '44100': 44100,
+    '22050': 22050,
+    '11025': 11025,
+};
+export const AUDIO_SAMPLE_RATE_TO_STRING = {
+    0: 'auto', 48000: '48000', 44100: '44100', 22050: '22050', 11025: '11025',
+};
+export const MATERIAL_FIELD_TYPE_STRINGS = {
+    texture: 0,
+    color: 1,
+    float: 2,
+    vec2: 3,
+    vec3: 4,
+    vec4: 5,
+    int: 6,
+};
+export const MATERIAL_FIELD_TYPE_TO_STRING = {
+    0: 'texture', 1: 'color', 2: 'float', 3: 'vec2', 4: 'vec3', 5: 'vec4', 6: 'int',
+};
+export const PREVIEW_FLAG_STRINGS = {
+    none: 0,
+    mainTex: 1,
+    tint: 2,
+    alphaTest: 3,
+};
+export const PREVIEW_FLAG_TO_STRING = {
+    0: 'none', 1: 'mainTex', 2: 'tint', 3: 'alphaTest',
+};

package/dist/app/process-cache.d.ts

@@ -0,0 +1,10 @@
+import type { AssetSettings } from './state.js';
+import type { StowMeta, StowMetaCache, FileSnapshot } from './disk-project.js';
+import type { AssetType } from '../core/types.js';
+export declare function cachePath(relativePath: string): string;
+export declare function writeCacheBlobs(srcArtDir: string, relativePath: string, entries: Map<string, Uint8Array>): Promise<void>;
+export declare function readCacheBlobs(srcArtDir: string, relativePath: string): Promise<Map<string, Uint8Array> | null>;
+export declare function deleteCacheFile(srcArtDir: string, relativePath: string): Promise<void>;
+export declare function computeSettingsHash(type: AssetType, settings: AssetSettings): string;
+export declare function isCacheValid(meta: StowMeta, sourceSnapshot: FileSnapshot, type: AssetType, settings: AssetSettings): boolean;
+export declare function buildCacheStamp(sourceSnapshot: FileSnapshot, type: AssetType, settings: AssetSettings): StowMetaCache;

package/dist/app/process-cache.js

@@ -0,0 +1,126 @@
+import { readFile, writeFile, deleteFile } from '../node-fs.js';
+// ─── Cache File Path ─────────────────────────────────────────────────────────
+export function cachePath(relativePath) {
+    return `${relativePath}.stowcache`;
+}
+// ─── Binary Cache Format ─────────────────────────────────────────────────────
+export async function writeCacheBlobs(srcArtDir, relativePath, entries) {
+    try {
+        const encoder = new TextEncoder();
+        let totalSize = 4;
+        const encodedKeys = [];
+        for (const [key, data] of entries) {
+            const keyBytes = encoder.encode(key);
+            encodedKeys.push(keyBytes);
+            totalSize += 2 + keyBytes.length + 4 + data.length;
+        }
+        const buffer = new ArrayBuffer(totalSize);
+        const view = new DataView(buffer);
+        const bytes = new Uint8Array(buffer);
+        let offset = 0;
+        view.setUint32(offset, entries.size, true);
+        offset += 4;
+        let keyIdx = 0;
+        for (const [_key, data] of entries) {
+            const keyBytes = encodedKeys[keyIdx++];
+            view.setUint16(offset, keyBytes.length, true);
+            offset += 2;
+            bytes.set(keyBytes, offset);
+            offset += keyBytes.length;
+            view.setUint32(offset, data.length, true);
+            offset += 4;
+            bytes.set(data, offset);
+            offset += data.length;
+        }
+        await writeFile(srcArtDir, cachePath(relativePath), bytes);
+    }
+    catch (err) {
+        console.warn(`[cache] Failed to write cache for ${relativePath}:`, err);
+    }
+}
+export async function readCacheBlobs(srcArtDir, relativePath) {
+    try {
+        const data = await readFile(srcArtDir, cachePath(relativePath));
+        if (!data || data.length < 4)
+            return null;
+        const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        const decoder = new TextDecoder();
+        const result = new Map();
+        let offset = 0;
+        const entryCount = view.getUint32(offset, true);
+        offset += 4;
+        for (let i = 0; i < entryCount; i++) {
+            if (offset + 2 > data.length)
+                return null;
+            const keyLen = view.getUint16(offset, true);
+            offset += 2;
+            if (offset + keyLen > data.length)
+                return null;
+            const key = decoder.decode(data.subarray(offset, offset + keyLen));
+            offset += keyLen;
+            if (offset + 4 > data.length)
+                return null;
+            const dataLen = view.getUint32(offset, true);
+            offset += 4;
+            if (offset + dataLen > data.length)
+                return null;
+            const entryData = data.slice(offset, offset + dataLen);
+            offset += dataLen;
+            result.set(key, entryData);
+        }
+        return result;
+    }
+    catch {
+        return null;
+    }
+}
+export async function deleteCacheFile(srcArtDir, relativePath) {
+    try {
+        await deleteFile(srcArtDir, cachePath(relativePath));
+    }
+    catch {
+        // Ignore
+    }
+}
+// ─── Settings Hash ───────────────────────────────────────────────────────────
+export function computeSettingsHash(type, settings) {
+    const parts = [String(type)];
+    switch (type) {
+        case 2: // Texture2D
+            parts.push(`q=${settings.quality}`, `r=${settings.resize}`, `m=${settings.generateMipmaps}`);
+            break;
+        case 3: // Audio
+            parts.push(`aq=${settings.aacQuality}`, `sr=${settings.audioSampleRate}`);
+            break;
+        case 1: // StaticMesh
+            parts.push(`dq=${settings.dracoQuality}`);
+            break;
+        case 5: // SkinnedMesh
+            parts.push('v2');
+            break;
+        case 6: // AnimationClip
+            parts.push('v2');
+            break;
+    }
+    return parts.join('|');
+}
+// ─── Cache Validity ──────────────────────────────────────────────────────────
+export function isCacheValid(meta, sourceSnapshot, type, settings) {
+    if (!meta.cache)
+        return false;
+    if (meta.cache.sourceSize !== sourceSnapshot.size)
+        return false;
+    if (meta.cache.sourceLastModified !== sourceSnapshot.lastModified)
+        return false;
+    const currentHash = computeSettingsHash(type, settings);
+    if (meta.cache.settingsHash !== currentHash)
+        return false;
+    return true;
+}
+export function buildCacheStamp(sourceSnapshot, type, settings) {
+    return {
+        sourceSize: sourceSnapshot.size,
+        sourceLastModified: sourceSnapshot.lastModified,
+        settingsHash: computeSettingsHash(type, settings),
+    };
+}

package/dist/app/state.d.ts

@@ -0,0 +1,38 @@
+import type { AssetType, TextureMetadata, AudioMetadata, MeshMetadata, AnimationClipMetadata, SkinnedMeshMetadata, KTX2Quality, TextureResize, DracoQualityPreset, AacQuality, AudioSampleRate, MaterialFieldType, PreviewPropertyFlag } from '../core/types.js';
+export interface MaterialProperty {
+    fieldName: string;
+    fieldType: MaterialFieldType;
+    previewFlag: PreviewPropertyFlag;
+    value: [number, number, number, number];
+    textureAssetId: string | null;
+}
+export interface MaterialConfig {
+    schemaId: string;
+    properties: MaterialProperty[];
+}
+export interface AssetSettings {
+    quality: KTX2Quality;
+    resize: TextureResize;
+    generateMipmaps: boolean;
+    tags: string[];
+    dracoQuality: DracoQualityPreset;
+    aacQuality: AacQuality;
+    audioSampleRate: AudioSampleRate;
+    targetMeshId: string | null;
+    materialConfig: MaterialConfig;
+    materialOverrides: Record<number, string | null>;
+    pack: string;
+}
+export declare function defaultAssetSettings(): AssetSettings;
+export interface ProjectAsset {
+    id: string;
+    fileName: string;
+    stringId: string;
+    type: AssetType;
+    status: 'loading' | 'pending' | 'processing' | 'ready' | 'error';
+    error?: string;
+    settings: AssetSettings;
+    metadata?: TextureMetadata | AudioMetadata | MeshMetadata | AnimationClipMetadata | SkinnedMeshMetadata;
+    sourceSize: number;
+    processedSize: number;
+}

package/dist/app/state.js

@@ -0,0 +1,16 @@
+import { KTX2Quality as KQ, TextureResize as TR, DracoQualityPreset as DQ, AacQuality as AQ, AudioSampleRate as ASR, } from '../core/types.js';
+export function defaultAssetSettings() {
+    return {
+        quality: KQ.Fastest,
+        resize: TR.Full,
+        generateMipmaps: false,
+        tags: [],
+        dracoQuality: DQ.Balanced,
+        aacQuality: AQ.Medium,
+        audioSampleRate: ASR.Auto,
+        targetMeshId: null,
+        materialConfig: { schemaId: '', properties: [] },
+        materialOverrides: {},
+        pack: 'default',
+    };
+}

package/dist/app/stowmat-io.d.ts

@@ -0,0 +1,6 @@
+import type { MaterialConfig } from './state.js';
+import type { StowMat } from './disk-project.js';
+export declare function readStowmat(srcArtDir: string, relativePath: string): Promise<StowMat | null>;
+export declare function writeStowmat(srcArtDir: string, relativePath: string, mat: StowMat): Promise<void>;
+export declare function materialConfigToStowmat(config: MaterialConfig): StowMat;
+export declare function stowmatToMaterialConfig(mat: StowMat): MaterialConfig;

package/dist/app/stowmat-io.js

@@ -0,0 +1,48 @@
+import { MATERIAL_FIELD_TYPE_STRINGS, MATERIAL_FIELD_TYPE_TO_STRING, PREVIEW_FLAG_STRINGS, PREVIEW_FLAG_TO_STRING, } from './disk-project.js';
+import { MaterialFieldType, PreviewPropertyFlag } from '../core/types.js';
+import { readTextFile, writeFile } from '../node-fs.js';
+export async function readStowmat(srcArtDir, relativePath) {
+    const text = await readTextFile(srcArtDir, relativePath);
+    if (!text)
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeStowmat(srcArtDir, relativePath, mat) {
+    try {
+        const json = JSON.stringify(mat, null, 2);
+        await writeFile(srcArtDir, relativePath, json);
+    }
+    catch (err) {
+        console.warn(`[stowmat] Failed to write ${relativePath}:`, err);
+    }
+}
+export function materialConfigToStowmat(config) {
+    return {
+        version: 1,
+        schemaName: config.schemaId,
+        properties: config.properties.map((prop) => ({
+            fieldName: prop.fieldName,
+            fieldType: MATERIAL_FIELD_TYPE_TO_STRING[prop.fieldType] ?? 'color',
+            previewFlag: PREVIEW_FLAG_TO_STRING[prop.previewFlag] ?? 'none',
+            value: [...prop.value],
+            textureAsset: prop.textureAssetId,
+        })),
+    };
+}
+export function stowmatToMaterialConfig(mat) {
+    return {
+        schemaId: mat.schemaName ?? '',
+        properties: (mat.properties ?? []).map((prop) => ({
+            fieldName: prop.fieldName ?? '',
+            fieldType: MATERIAL_FIELD_TYPE_STRINGS[prop.fieldType] ?? MaterialFieldType.Color,
+            previewFlag: PREVIEW_FLAG_STRINGS[prop.previewFlag] ?? PreviewPropertyFlag.None,
+            value: prop.value ?? [1, 1, 1, 1],
+            textureAssetId: prop.textureAsset ?? null,
+        })),
+    };
+}

package/dist/app/stowmeta-io.d.ts

@@ -0,0 +1,14 @@
+import type { AssetSettings } from './state.js';
+import { AssetType } from '../core/types.js';
+import type { ProjectAsset } from './state.js';
+import type { StowMeta } from './disk-project.js';
+export declare function detectAssetType(fileName: string): AssetType;
+export declare function stowmetaPath(relativePath: string): string;
+export declare function readStowmeta(srcArtDir: string, relativePath: string): Promise<StowMeta | null>;
+export declare function writeStowmeta(srcArtDir: string, relativePath: string, meta: StowMeta): Promise<void>;
+export declare function stowmetaToAssetSettings(meta: StowMeta): {
+    type: AssetType;
+    settings: AssetSettings;
+};
+export declare function assetSettingsToStowmeta(asset: ProjectAsset): StowMeta;
+export declare function generateDefaultStowmeta(relativePath: string, type?: AssetType): StowMeta;

package/dist/app/stowmeta-io.js

@@ -0,0 +1,207 @@
+import { AssetType } from '../core/types.js';
+import { KTX2Quality, TextureResize, DracoQualityPreset, AacQuality, AudioSampleRate } from '../core/types.js';
+import { KTX2_QUALITY_STRINGS, KTX2_QUALITY_TO_STRING, TEXTURE_RESIZE_STRINGS, TEXTURE_RESIZE_TO_STRING, DRACO_QUALITY_STRINGS, DRACO_QUALITY_TO_STRING, AAC_QUALITY_STRINGS, AAC_QUALITY_TO_STRING, AUDIO_SAMPLE_RATE_STRINGS, AUDIO_SAMPLE_RATE_TO_STRING, } from './disk-project.js';
+import { readTextFile, writeFile } from '../node-fs.js';
+import { defaultAssetSettings } from './state.js';
+// ─── Detect asset type from file extension ──────────────────────────────────
+const TEXTURE_EXTENSIONS = new Set([
+    'png', 'jpg', 'jpeg', 'bmp', 'tga', 'webp', 'gif',
+]);
+const AUDIO_EXTENSIONS = new Set([
+    'wav', 'mp3', 'ogg', 'flac', 'aac', 'm4a',
+]);
+const MESH_EXTENSIONS = new Set([
+    'fbx', 'obj', 'gltf', 'glb',
+]);
+export function detectAssetType(fileName) {
+    const ext = fileName.split('.').pop()?.toLowerCase() ?? '';
+    if (TEXTURE_EXTENSIONS.has(ext))
+        return AssetType.Texture2D;
+    if (AUDIO_EXTENSIONS.has(ext))
+        return AssetType.Audio;
+    if (MESH_EXTENSIONS.has(ext))
+        return AssetType.StaticMesh;
+    return AssetType.Unknown;
+}
+// ─── Stowmeta path helper ───────────────────────────────────────────────────
+export function stowmetaPath(relativePath) {
+    return `${relativePath}.stowmeta`;
+}
+// ─── Read .stowmeta ─────────────────────────────────────────────────────────
+export async function readStowmeta(srcArtDir, relativePath) {
+    const metaPath = stowmetaPath(relativePath);
+    const text = await readTextFile(srcArtDir, metaPath);
+    if (!text)
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+// ─── Write .stowmeta ────────────────────────────────────────────────────────
+export async function writeStowmeta(srcArtDir, relativePath, meta) {
+    try {
+        const metaPath = stowmetaPath(relativePath);
+        const json = JSON.stringify(meta, null, 2);
+        await writeFile(srcArtDir, metaPath, json);
+    }
+    catch (err) {
+        console.warn(`[stowmeta] Failed to write meta for ${relativePath}:`, err);
+    }
+}
+// ─── Convert StowMeta → AssetSettings + type ────────────────────────────────
+export function stowmetaToAssetSettings(meta) {
+    const base = defaultAssetSettings();
+    base.tags = meta.tags ?? [];
+    base.pack = meta.pack ?? 'default';
+    switch (meta.type) {
+        case 'texture':
+            return {
+                type: AssetType.Texture2D,
+                settings: {
+                    ...base,
+                    quality: KTX2_QUALITY_STRINGS[meta.quality] ?? KTX2Quality.Fastest,
+                    resize: TEXTURE_RESIZE_STRINGS[meta.resize] ?? TextureResize.Full,
+                    generateMipmaps: meta.generateMipmaps ?? false,
+                },
+            };
+        case 'audio':
+            return {
+                type: AssetType.Audio,
+                settings: {
+                    ...base,
+                    aacQuality: AAC_QUALITY_STRINGS[meta.aacQuality] ?? AacQuality.Medium,
+                    audioSampleRate: AUDIO_SAMPLE_RATE_STRINGS[meta.sampleRate] ?? AudioSampleRate.Auto,
+                },
+            };
+        case 'staticMesh':
+            return {
+                type: AssetType.StaticMesh,
+                settings: {
+                    ...base,
+                    dracoQuality: DRACO_QUALITY_STRINGS[meta.dracoQuality] ?? DracoQualityPreset.Balanced,
+                    materialOverrides: parseMaterialOverrides(meta.materialOverrides),
+                },
+            };
+        case 'skinnedMesh':
+            return {
+                type: AssetType.SkinnedMesh,
+                settings: {
+                    ...base,
+                    materialOverrides: parseMaterialOverrides(meta.materialOverrides),
+                },
+            };
+        case 'animationClip':
+            return {
+                type: AssetType.AnimationClip,
+                settings: {
+                    ...base,
+                    targetMeshId: meta.targetMeshId ?? null,
+                },
+            };
+        case 'materialSchema':
+            return {
+                type: AssetType.MaterialSchema,
+                settings: base,
+            };
+        default:
+            return { type: AssetType.Unknown, settings: base };
+    }
+}
+function parseMaterialOverrides(raw) {
+    if (!raw)
+        return {};
+    const result = {};
+    for (const [key, value] of Object.entries(raw)) {
+        const idx = parseInt(key, 10);
+        if (!isNaN(idx))
+            result[idx] = value;
+    }
+    return result;
+}
+// ─── Convert AssetSettings → StowMeta ───────────────────────────────────────
+export function assetSettingsToStowmeta(asset) {
+    const base = {
+        version: 1,
+        stringId: asset.stringId,
+        tags: asset.settings.tags,
+        pack: asset.settings.pack,
+    };
+    switch (asset.type) {
+        case AssetType.Texture2D:
+            return {
+                ...base,
+                type: 'texture',
+                quality: KTX2_QUALITY_TO_STRING[asset.settings.quality] ?? 'fastest',
+                resize: TEXTURE_RESIZE_TO_STRING[asset.settings.resize] ?? 'full',
+                generateMipmaps: asset.settings.generateMipmaps,
+            };
+        case AssetType.Audio:
+            return {
+                ...base,
+                type: 'audio',
+                aacQuality: AAC_QUALITY_TO_STRING[asset.settings.aacQuality] ?? 'medium',
+                sampleRate: AUDIO_SAMPLE_RATE_TO_STRING[asset.settings.audioSampleRate] ?? 'auto',
+            };
+        case AssetType.StaticMesh:
+            return {
+                ...base,
+                type: 'staticMesh',
+                dracoQuality: DRACO_QUALITY_TO_STRING[asset.settings.dracoQuality] ?? 'balanced',
+                materialOverrides: serializeMaterialOverrides(asset.settings.materialOverrides),
+            };
+        case AssetType.SkinnedMesh:
+            return {
+                ...base,
+                type: 'skinnedMesh',
+                materialOverrides: serializeMaterialOverrides(asset.settings.materialOverrides),
+            };
+        case AssetType.AnimationClip:
+            return {
+                ...base,
+                type: 'animationClip',
+                targetMeshId: asset.settings.targetMeshId ?? null,
+            };
+        case AssetType.MaterialSchema:
+            return { ...base, type: 'materialSchema' };
+        default:
+            return { ...base, type: 'materialSchema' };
+    }
+}
+function serializeMaterialOverrides(overrides) {
+    const result = {};
+    for (const [key, value] of Object.entries(overrides))
+        result[key] = value;
+    return result;
+}
+// ─── Generate default .stowmeta ─────────────────────────────────────────────
+export function generateDefaultStowmeta(relativePath, type) {
+    const fileName = relativePath.split('/').pop() ?? relativePath;
+    const resolvedType = type ?? detectAssetType(fileName);
+    const baseName = fileName.replace(/\.[^.]+$/, '');
+    const stringId = resolvedType === AssetType.MaterialSchema ? baseName : baseName.toLowerCase();
+    const base = {
+        version: 1,
+        stringId,
+        tags: [],
+        pack: 'default',
+    };
+    switch (resolvedType) {
+        case AssetType.Texture2D:
+            return { ...base, type: 'texture', quality: 'fastest', resize: 'full', generateMipmaps: false };
+        case AssetType.Audio:
+            return { ...base, type: 'audio', aacQuality: 'medium', sampleRate: 'auto' };
+        case AssetType.StaticMesh:
+            return { ...base, type: 'staticMesh', dracoQuality: 'balanced', materialOverrides: {} };
+        case AssetType.SkinnedMesh:
+            return { ...base, type: 'skinnedMesh', materialOverrides: {} };
+        case AssetType.AnimationClip:
+            return { ...base, type: 'animationClip', targetMeshId: null };
+        case AssetType.MaterialSchema:
+            return { ...base, type: 'materialSchema' };
+        default:
+            return { ...base, type: 'materialSchema' };
+    }
+}