@series-inc/stowkit-cli 0.1.11 → 0.1.13

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

@@ -5,5 +5,7 @@ export declare const BlobStore: {
     getProcessed(id: string): Uint8Array | undefined;
     remove(id: string): void;
     renameAll(oldId: string, newId: string): void;
+    getAllProcessed(): Map<string, Uint8Array>;
+    clearProcessed(): void;
     clear(): void;
 };

package/dist/app/blob-store.js

@@ -35,6 +35,12 @@ export const BlobStore = {
             }
         }
     },
+    getAllProcessed() {
+        return new Map(processedBlobs);
+    },
+    clearProcessed() {
+        processedBlobs.clear();
+    },
     clear() {
         sourceBlobs.clear();
         processedBlobs.clear();

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

@@ -25,7 +25,9 @@ interface StowMetaBase {
     stringId: string;
     tags: string[];
     pack?: string;
+    excluded?: boolean;
     cache?: StowMetaCache;
+    parentId?: string;
 }
 export interface StowMetaTexture extends StowMetaBase {
     type: 'texture';
@@ -42,6 +44,7 @@ export interface StowMetaStaticMesh extends StowMetaBase {
     type: 'staticMesh';
     dracoQuality: string;
     materialOverrides: Record<string, string | null>;
+    preserveHierarchy?: boolean;
 }
 export interface StowMetaSkinnedMesh extends StowMetaBase {
     type: 'skinnedMesh';
@@ -54,7 +57,33 @@ export interface StowMetaAnimationClip extends StowMetaBase {
 export interface StowMetaMaterialSchema extends StowMetaBase {
     type: 'materialSchema';
 }
-export type StowMeta = StowMetaTexture | StowMetaAudio | StowMetaStaticMesh | StowMetaSkinnedMesh | StowMetaAnimationClip | StowMetaMaterialSchema;
+export interface StowMetaGlbChild {
+    name: string;
+    childType: string;
+    stringId: string;
+    excluded?: boolean;
+    tags?: string[];
+    pack?: string;
+    cache?: StowMetaCache;
+    quality?: string;
+    resize?: string;
+    generateMipmaps?: boolean;
+    aacQuality?: string;
+    sampleRate?: string;
+    dracoQuality?: string;
+    materialOverrides?: Record<string, string | null>;
+    targetMeshId?: string | null;
+    materialConfig?: {
+        schemaId: string;
+        properties: StowMatProperty[];
+    };
+}
+export interface StowMetaGlbContainer extends StowMetaBase {
+    type: 'glbContainer';
+    preserveHierarchy?: boolean;
+    children: StowMetaGlbChild[];
+}
+export type StowMeta = StowMetaTexture | StowMetaAudio | StowMetaStaticMesh | StowMetaSkinnedMesh | StowMetaAnimationClip | StowMetaMaterialSchema | StowMetaGlbContainer;
 export interface StowMatProperty {
     fieldName: string;
     fieldType: string;

package/dist/app/process-cache.js

@@ -1,6 +1,15 @@
 import { readFile, writeFile, deleteFile } from '../node-fs.js';
 // ─── Cache File Path ─────────────────────────────────────────────────────────
+const GLB_CONTAINER_EXTS = /\.(glb|gltf)\//i;
 export function cachePath(relativePath) {
+    // For container children, redirect to companion dir
+    const match = relativePath.match(GLB_CONTAINER_EXTS);
+    if (match) {
+        const containerEnd = relativePath.indexOf('/', match.index);
+        const containerPath = relativePath.substring(0, containerEnd);
+        const childName = relativePath.substring(containerEnd + 1);
+        return `${containerPath}.children/${childName}.stowcache`;
+    }
     return `${relativePath}.stowcache`;
 }
 // ─── Binary Cache Format ─────────────────────────────────────────────────────
@@ -101,6 +110,9 @@ export function computeSettingsHash(type, settings) {
         case 6: // AnimationClip
             parts.push('v2');
             break;
+        case 7: // GlbContainer
+            parts.push('v1');
+            break;
     }
     return parts.join('|');
 }

package/dist/app/state.d.ts

@@ -22,6 +22,8 @@ export interface AssetSettings {
     materialConfig: MaterialConfig;
     materialOverrides: Record<number, string | null>;
     pack: string;
+    excluded: boolean;
+    preserveHierarchy: boolean;
 }
 export declare function defaultAssetSettings(): AssetSettings;
 export interface ProjectAsset {
@@ -35,4 +37,6 @@ export interface ProjectAsset {
     metadata?: TextureMetadata | AudioMetadata | MeshMetadata | AnimationClipMetadata | SkinnedMeshMetadata;
     sourceSize: number;
     processedSize: number;
+    parentId?: string;
+    locked?: boolean;
 }

package/dist/app/state.js

@@ -12,5 +12,7 @@ export function defaultAssetSettings() {
         materialConfig: { schemaId: '', properties: [] },
         materialOverrides: {},
         pack: 'default',
+        excluded: false,
+        preserveHierarchy: false,
     };
 }

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

@@ -1,7 +1,7 @@
 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';
+import type { StowMeta, StowMetaGlbChild } 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>;
@@ -12,3 +12,20 @@ export declare function stowmetaToAssetSettings(meta: StowMeta): {
 };
 export declare function assetSettingsToStowmeta(asset: ProjectAsset): StowMeta;
 export declare function generateDefaultStowmeta(relativePath: string, type?: AssetType): StowMeta;
+/** Generate a default inline child entry for a GLB container. */
+export declare function generateDefaultGlbChild(name: string, childType: string): StowMetaGlbChild;
+/** Convert an inline child entry to { type, settings } for use in ProjectAsset. */
+export declare function glbChildToAssetSettings(child: StowMetaGlbChild): {
+    type: AssetType;
+    settings: AssetSettings;
+};
+/** Convert runtime AssetSettings back to inline child fields (merges into existing child). */
+export declare function assetSettingsToGlbChild(name: string, childType: string, stringId: string, settings: AssetSettings, existing?: StowMetaGlbChild): StowMetaGlbChild;
+/** Read a specific child's settings from the container's stowmeta. */
+export declare function readGlbChildSettings(srcArtDir: string, containerId: string, childName: string): Promise<{
+    child: StowMetaGlbChild;
+    type: AssetType;
+    settings: AssetSettings;
+} | null>;
+/** Write/merge a child's settings into the container's stowmeta. */
+export declare function writeGlbChildSettings(srcArtDir: string, containerId: string, childName: string, stringId: string, childType: string, settings: AssetSettings): Promise<void>;

package/dist/app/stowmeta-io.js

@@ -1,6 +1,6 @@
 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 { KTX2Quality, TextureResize, DracoQualityPreset, AacQuality, AudioSampleRate, MaterialFieldType, PreviewPropertyFlag } 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, MATERIAL_FIELD_TYPE_STRINGS, MATERIAL_FIELD_TYPE_TO_STRING, PREVIEW_FLAG_STRINGS, PREVIEW_FLAG_TO_STRING, } from './disk-project.js';
 import { readTextFile, writeFile } from '../node-fs.js';
 import { defaultAssetSettings } from './state.js';
 // ─── Detect asset type from file extension ──────────────────────────────────
@@ -11,7 +11,10 @@ const AUDIO_EXTENSIONS = new Set([
     'wav', 'mp3', 'ogg', 'flac', 'aac', 'm4a',
 ]);
 const MESH_EXTENSIONS = new Set([
-    'fbx', 'obj', 'gltf', 'glb',
+    'fbx', 'obj',
+]);
+const GLB_EXTENSIONS = new Set([
+    'gltf', 'glb',
 ]);
 export function detectAssetType(fileName) {
     const ext = fileName.split('.').pop()?.toLowerCase() ?? '';
@@ -21,6 +24,8 @@ export function detectAssetType(fileName) {
         return AssetType.Audio;
     if (MESH_EXTENSIONS.has(ext))
         return AssetType.StaticMesh;
+    if (GLB_EXTENSIONS.has(ext))
+        return AssetType.GlbContainer;
     return AssetType.Unknown;
 }
 // ─── Stowmeta path helper ───────────────────────────────────────────────────
@@ -56,6 +61,7 @@ export function stowmetaToAssetSettings(meta) {
     const base = defaultAssetSettings();
     base.tags = meta.tags ?? [];
     base.pack = meta.pack ?? 'default';
+    base.excluded = meta.excluded ?? false;
     switch (meta.type) {
         case 'texture':
             return {
@@ -83,6 +89,7 @@ export function stowmetaToAssetSettings(meta) {
                     ...base,
                     dracoQuality: DRACO_QUALITY_STRINGS[meta.dracoQuality] ?? DracoQualityPreset.Balanced,
                     materialOverrides: parseMaterialOverrides(meta.materialOverrides),
+                    preserveHierarchy: meta.preserveHierarchy ?? false,
                 },
             };
         case 'skinnedMesh':
@@ -106,6 +113,14 @@ export function stowmetaToAssetSettings(meta) {
                 type: AssetType.MaterialSchema,
                 settings: base,
             };
+        case 'glbContainer':
+            return {
+                type: AssetType.GlbContainer,
+                settings: {
+                    ...base,
+                    preserveHierarchy: meta.preserveHierarchy ?? false,
+                },
+            };
         default:
             return { type: AssetType.Unknown, settings: base };
     }
@@ -128,6 +143,7 @@ export function assetSettingsToStowmeta(asset) {
         stringId: asset.stringId,
         tags: asset.settings.tags,
         pack: asset.settings.pack,
+        excluded: asset.settings.excluded || undefined,
     };
     switch (asset.type) {
         case AssetType.Texture2D:
@@ -151,6 +167,7 @@ export function assetSettingsToStowmeta(asset) {
                 type: 'staticMesh',
                 dracoQuality: DRACO_QUALITY_TO_STRING[asset.settings.dracoQuality] ?? 'balanced',
                 materialOverrides: serializeMaterialOverrides(asset.settings.materialOverrides),
+                preserveHierarchy: asset.settings.preserveHierarchy || undefined,
             };
         case AssetType.SkinnedMesh:
             return {
@@ -166,6 +183,8 @@ export function assetSettingsToStowmeta(asset) {
             };
         case AssetType.MaterialSchema:
             return { ...base, type: 'materialSchema' };
+        case AssetType.GlbContainer:
+            return { ...base, type: 'glbContainer', preserveHierarchy: asset.settings.preserveHierarchy || undefined, children: [] };
         default:
             return { ...base, type: 'materialSchema' };
     }
@@ -201,7 +220,199 @@ export function generateDefaultStowmeta(relativePath, type) {
             return { ...base, type: 'animationClip', targetMeshId: null };
         case AssetType.MaterialSchema:
             return { ...base, type: 'materialSchema' };
+        case AssetType.GlbContainer:
+            return { ...base, type: 'glbContainer', children: [] };
         default:
             return { ...base, type: 'materialSchema' };
     }
 }
+// ─── GLB Inline Child Helpers ───────────────────────────────────────────────
+/** Generate a default inline child entry for a GLB container. */
+export function generateDefaultGlbChild(name, childType) {
+    const baseName = name.replace(/\.[^.]+$/, '');
+    const stringId = childType === 'materialSchema' ? baseName : baseName.toLowerCase();
+    const child = { name, childType, stringId };
+    switch (childType) {
+        case 'texture':
+            child.quality = 'fastest';
+            child.resize = 'full';
+            child.generateMipmaps = false;
+            break;
+        case 'audio':
+            child.aacQuality = 'medium';
+            child.sampleRate = 'auto';
+            break;
+        case 'staticMesh':
+        case 'skinnedMesh':
+            child.dracoQuality = 'balanced';
+            child.materialOverrides = {};
+            break;
+        case 'animationClip':
+            child.targetMeshId = null;
+            break;
+        case 'materialSchema':
+            break;
+    }
+    return child;
+}
+/** Convert an inline child entry to { type, settings } for use in ProjectAsset. */
+export function glbChildToAssetSettings(child) {
+    const base = defaultAssetSettings();
+    base.tags = child.tags ?? [];
+    base.pack = child.pack ?? 'default';
+    base.excluded = child.excluded ?? false;
+    switch (child.childType) {
+        case 'texture':
+            return {
+                type: AssetType.Texture2D,
+                settings: {
+                    ...base,
+                    quality: KTX2_QUALITY_STRINGS[child.quality ?? 'fastest'] ?? KTX2Quality.Fastest,
+                    resize: TEXTURE_RESIZE_STRINGS[child.resize ?? 'full'] ?? TextureResize.Full,
+                    generateMipmaps: child.generateMipmaps ?? false,
+                },
+            };
+        case 'audio':
+            return {
+                type: AssetType.Audio,
+                settings: {
+                    ...base,
+                    aacQuality: AAC_QUALITY_STRINGS[child.aacQuality ?? 'medium'] ?? AacQuality.Medium,
+                    audioSampleRate: AUDIO_SAMPLE_RATE_STRINGS[child.sampleRate ?? 'auto'] ?? AudioSampleRate.Auto,
+                },
+            };
+        case 'staticMesh':
+            return {
+                type: AssetType.StaticMesh,
+                settings: {
+                    ...base,
+                    dracoQuality: DRACO_QUALITY_STRINGS[child.dracoQuality ?? 'balanced'] ?? DracoQualityPreset.Balanced,
+                    materialOverrides: parseMaterialOverrides(child.materialOverrides),
+                },
+            };
+        case 'skinnedMesh':
+            return {
+                type: AssetType.SkinnedMesh,
+                settings: {
+                    ...base,
+                    materialOverrides: parseMaterialOverrides(child.materialOverrides),
+                },
+            };
+        case 'animationClip':
+            return {
+                type: AssetType.AnimationClip,
+                settings: {
+                    ...base,
+                    targetMeshId: child.targetMeshId ?? null,
+                },
+            };
+        case 'materialSchema':
+            if (child.materialConfig) {
+                base.materialConfig = glbChildMaterialConfigToRuntime(child.materialConfig);
+            }
+            return {
+                type: AssetType.MaterialSchema,
+                settings: base,
+            };
+        default:
+            return { type: AssetType.Unknown, settings: base };
+    }
+}
+/** Convert runtime AssetSettings back to inline child fields (merges into existing child). */
+export function assetSettingsToGlbChild(name, childType, stringId, settings, existing) {
+    const child = {
+        ...(existing ?? {}),
+        name,
+        childType,
+        stringId,
+    };
+    if (settings.tags?.length)
+        child.tags = settings.tags;
+    else
+        delete child.tags;
+    if (settings.pack && settings.pack !== 'default')
+        child.pack = settings.pack;
+    else
+        delete child.pack;
+    if (settings.excluded)
+        child.excluded = true;
+    else
+        delete child.excluded;
+    switch (childType) {
+        case 'texture':
+            child.quality = KTX2_QUALITY_TO_STRING[settings.quality] ?? 'fastest';
+            child.resize = TEXTURE_RESIZE_TO_STRING[settings.resize] ?? 'full';
+            child.generateMipmaps = settings.generateMipmaps;
+            break;
+        case 'audio':
+            child.aacQuality = AAC_QUALITY_TO_STRING[settings.aacQuality] ?? 'medium';
+            child.sampleRate = AUDIO_SAMPLE_RATE_TO_STRING[settings.audioSampleRate] ?? 'auto';
+            break;
+        case 'staticMesh':
+        case 'skinnedMesh':
+            child.dracoQuality = DRACO_QUALITY_TO_STRING[settings.dracoQuality] ?? 'balanced';
+            child.materialOverrides = serializeMaterialOverrides(settings.materialOverrides);
+            break;
+        case 'animationClip':
+            child.targetMeshId = settings.targetMeshId ?? null;
+            break;
+        case 'materialSchema':
+            if (settings.materialConfig && settings.materialConfig.properties.length > 0) {
+                child.materialConfig = runtimeMaterialConfigToGlbChild(settings.materialConfig);
+            }
+            break;
+    }
+    return child;
+}
+/** Read a specific child's settings from the container's stowmeta. */
+export async function readGlbChildSettings(srcArtDir, containerId, childName) {
+    const containerMeta = await readStowmeta(srcArtDir, containerId);
+    if (!containerMeta || containerMeta.type !== 'glbContainer')
+        return null;
+    const child = containerMeta.children.find(c => c.name === childName);
+    if (!child)
+        return null;
+    const { type, settings } = glbChildToAssetSettings(child);
+    return { child, type, settings };
+}
+/** Write/merge a child's settings into the container's stowmeta. */
+export async function writeGlbChildSettings(srcArtDir, containerId, childName, stringId, childType, settings) {
+    const containerMeta = await readStowmeta(srcArtDir, containerId);
+    if (!containerMeta || containerMeta.type !== 'glbContainer')
+        return;
+    const idx = containerMeta.children.findIndex(c => c.name === childName);
+    const existing = idx >= 0 ? containerMeta.children[idx] : undefined;
+    const updated = assetSettingsToGlbChild(childName, childType, stringId, settings, existing);
+    if (idx >= 0) {
+        containerMeta.children[idx] = updated;
+    }
+    else {
+        containerMeta.children.push(updated);
+    }
+    await writeStowmeta(srcArtDir, containerId, containerMeta);
+}
+// ─── Material config conversion for inline GLB children ─────────────────────
+function glbChildMaterialConfigToRuntime(config) {
+    return {
+        schemaId: config.schemaId ?? '',
+        properties: (config.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,
+        })),
+    };
+}
+function runtimeMaterialConfigToGlbChild(config) {
+    return {
+        schemaId: 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,
+        })),
+    };
+}

package/dist/cleanup.js

@@ -48,6 +48,8 @@ async function walkForOrphans(basePath, prefix, sourceFiles, matFiles, onOrphan)
         if (entry.isDirectory()) {
             if (entry.name.startsWith('.'))
                 continue;
+            if (entry.name.endsWith('.children'))
+                continue;
             await walkForOrphans(basePath, relativePath, sourceFiles, matFiles, onOrphan);
         }
         else if (entry.isFile()) {

package/dist/core/types.d.ts

@@ -5,7 +5,8 @@ export declare enum AssetType {
     Audio = 3,
     MaterialSchema = 4,
     SkinnedMesh = 5,
-    AnimationClip = 6
+    AnimationClip = 6,
+    GlbContainer = 7
 }
 export declare enum KTX2Quality {
     Fastest = 0,

package/dist/core/types.js

@@ -8,6 +8,7 @@ export var AssetType;
     AssetType[AssetType["MaterialSchema"] = 4] = "MaterialSchema";
     AssetType[AssetType["SkinnedMesh"] = 5] = "SkinnedMesh";
     AssetType[AssetType["AnimationClip"] = 6] = "AnimationClip";
+    AssetType[AssetType["GlbContainer"] = 7] = "GlbContainer";
 })(AssetType || (AssetType = {}));
 // ─── Texture Enums ──────────────────────────────────────────────────────────
 export var KTX2Quality;

package/dist/encoders/fbx-loader.d.ts

@@ -1,4 +1,4 @@
-import type { IMeshImporter, ImportedMesh } from './interfaces.js';
+import type { IMeshImporter, MeshImportOpts, ImportedMesh } from './interfaces.js';
 export declare class NodeFbxImporter implements IMeshImporter {
-    import(data: Uint8Array, _fileName: string): Promise<ImportedMesh>;
+    import(data: Uint8Array, _fileName: string, opts?: MeshImportOpts): Promise<ImportedMesh>;
 }

package/dist/encoders/fbx-loader.js

@@ -49,13 +49,15 @@ function ensureDomShim() {
 }
 // ─── FBX Importer ────────────────────────────────────────────────────────────
 export class NodeFbxImporter {
-    async import(data, _fileName) {
+    async import(data, _fileName, opts) {
         ensureDomShim();
         try {
             const loader = new FBXLoader();
             const buffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
             const group = loader.parse(buffer, '');
-            const mesh = extractMeshFromGroup(group);
+            const mesh = opts?.preserveHierarchy
+                ? extractMeshFromGroupHierarchical(group)
+                : extractMeshFromGroup(group);
             mesh.animations = parseFbxAnimations(data);
             return mesh;
         }
@@ -298,6 +300,142 @@ function extractMeshFromGroup(group) {
         animations: [],
     };
 }
+// ─── Hierarchical Group → ImportedMesh extraction ────────────────────────────
+function extractMeshFromGroupHierarchical(group) {
+    group.updateMatrixWorld(true);
+    // Collect all relevant nodes — skip Bone, Light, Camera, SkinnedMesh
+    const nodeList = [];
+    const nodeIndexMap = new Map();
+    function collectNodes(obj) {
+        if (obj.isBone)
+            return;
+        if (obj.isLight)
+            return;
+        if (obj.isCamera)
+            return;
+        if (obj.isSkinnedMesh)
+            return;
+        nodeIndexMap.set(obj, nodeList.length);
+        nodeList.push(obj);
+        for (const child of obj.children) {
+            collectNodes(child);
+        }
+    }
+    for (const child of group.children) {
+        collectNodes(child);
+    }
+    if (nodeList.length === 0)
+        return emptyMesh();
+    const subMeshes = [];
+    const materials = [];
+    const materialSet = new Map();
+    const nodes = [];
+    for (let ni = 0; ni < nodeList.length; ni++) {
+        const obj = nodeList[ni];
+        const isMesh = obj.isMesh;
+        // Determine parent index
+        let parentIndex = -1;
+        let ancestor = obj.parent;
+        while (ancestor && ancestor !== group) {
+            const idx = nodeIndexMap.get(ancestor);
+            if (idx !== undefined) {
+                parentIndex = idx;
+                break;
+            }
+            ancestor = ancestor.parent;
+        }
+        // Local transform
+        const pos = [obj.position.x, obj.position.y, obj.position.z];
+        const rot = [obj.quaternion.x, obj.quaternion.y, obj.quaternion.z, obj.quaternion.w];
+        const scl = [obj.scale.x, obj.scale.y, obj.scale.z];
+        const meshIndices = [];
+        if (isMesh) {
+            const mesh = obj;
+            const geometry = mesh.geometry;
+            const posAttr = geometry.getAttribute('position');
+            if (!posAttr) {
+                nodes.push({ name: obj.name || `node_${ni}`, parentIndex, position: pos, rotation: rot, scale: scl, meshIndices: [] });
+                continue;
+            }
+            const vertCount = posAttr.count;
+            // Store positions in LOCAL space (no matrixWorld bake)
+            const positions = new Float32Array(vertCount * 3);
+            for (let vi = 0; vi < vertCount; vi++) {
+                positions[vi * 3] = posAttr.getX(vi);
+                positions[vi * 3 + 1] = posAttr.getY(vi);
+                positions[vi * 3 + 2] = posAttr.getZ(vi);
+            }
+            // Normals in local space
+            let normals = null;
+            const normAttr = geometry.getAttribute('normal');
+            if (normAttr && normAttr.count === vertCount) {
+                normals = new Float32Array(vertCount * 3);
+                const localNormalMatrix = new THREE.Matrix3().getNormalMatrix(mesh.matrix);
+                const n = new THREE.Vector3();
+                for (let vi = 0; vi < vertCount; vi++) {
+                    n.fromBufferAttribute(normAttr, vi);
+                    n.applyMatrix3(localNormalMatrix).normalize();
+                    normals[vi * 3] = n.x;
+                    normals[vi * 3 + 1] = n.y;
+                    normals[vi * 3 + 2] = n.z;
+                }
+            }
+            // UVs — FBX convention: no V-flip
+            let uvs = null;
+            const uvAttr = geometry.getAttribute('uv');
+            if (uvAttr && uvAttr.count === vertCount) {
+                uvs = new Float32Array(vertCount * 2);
+                for (let vi = 0; vi < vertCount; vi++) {
+                    uvs[vi * 2] = uvAttr.getX(vi);
+                    uvs[vi * 2 + 1] = uvAttr.getY(vi);
+                }
+            }
+            const indexAttr = geometry.getIndex();
+            let indices;
+            if (indexAttr) {
+                indices = new Uint32Array(indexAttr.count);
+                for (let ii = 0; ii < indexAttr.count; ii++)
+                    indices[ii] = indexAttr.getX(ii);
+            }
+            else {
+                indices = new Uint32Array(vertCount);
+                for (let ii = 0; ii < vertCount; ii++)
+                    indices[ii] = ii;
+            }
+            const meshMaterial = Array.isArray(mesh.material) ? mesh.material[0] : mesh.material;
+            const matName = meshMaterial?.name || 'default';
+            let matIndex;
+            if (materialSet.has(matName)) {
+                matIndex = materialSet.get(matName);
+            }
+            else {
+                matIndex = materials.length;
+                materialSet.set(matName, matIndex);
+                materials.push({ name: matName });
+            }
+            meshIndices.push(subMeshes.length);
+            subMeshes.push({ positions, normals, uvs, indices, materialIndex: matIndex });
+        }
+        nodes.push({
+            name: obj.name || `node_${ni}`,
+            parentIndex,
+            position: pos,
+            rotation: rot,
+            scale: scl,
+            meshIndices,
+        });
+    }
+    if (materials.length === 0)
+        materials.push({ name: 'default' });
+    return {
+        subMeshes,
+        materials,
+        nodes,
+        hasSkeleton: false,
+        bones: [],
+        animations: [],
+    };
+}
 function emptyMesh() {
     return { subMeshes: [], materials: [{ name: 'default' }], nodes: [], hasSkeleton: false, bones: [], animations: [] };
 }