@series-inc/stowkit-cli 0.1.0

package/dist/core/types.d.ts

@@ -0,0 +1,204 @@
+export declare enum AssetType {
+    Unknown = 0,
+    StaticMesh = 1,
+    Texture2D = 2,
+    Audio = 3,
+    MaterialSchema = 4,
+    SkinnedMesh = 5,
+    AnimationClip = 6
+}
+export declare enum KTX2Quality {
+    Fastest = 0,
+    Fast = 1,
+    Normal = 2,
+    High = 3,
+    Best = 4
+}
+export declare enum TextureChannelFormat {
+    Auto = 0,
+    RGB = 1,
+    RGBA = 2
+}
+export declare enum TextureResize {
+    Full = 0,
+    Half = 1,
+    Quarter = 2,
+    Eighth = 3
+}
+export declare enum MaterialFieldType {
+    Texture = 0,
+    Color = 1,
+    Float = 2,
+    Vec2 = 3,
+    Vec3 = 4,
+    Vec4 = 5,
+    Int = 6
+}
+export declare enum PreviewPropertyFlag {
+    None = 0,
+    MainTex = 1,
+    Tint = 2,
+    AlphaTest = 3
+}
+export declare enum AacQuality {
+    Lowest = 0,
+    Low = 1,
+    Medium = 2,
+    High = 3,
+    Best = 4
+}
+export declare enum AudioSampleRate {
+    Auto = 0,
+    Hz48000 = 48000,
+    Hz44100 = 44100,
+    Hz22050 = 22050,
+    Hz11025 = 11025
+}
+export declare enum DracoQualityPreset {
+    Fast = 0,
+    Balanced = 1,
+    HighQuality = 2,
+    MaximumQuality = 3
+}
+export interface FileHeader {
+    magic: number;
+    version: number;
+    assetCount: number;
+    directoryOffset: number;
+}
+export interface AssetDirectoryEntry {
+    assetUID: bigint;
+    assetType: AssetType;
+    dataOffset: number;
+    dataSize: number;
+    metadataOffset: number;
+    metadataSize: number;
+}
+export interface TextureMetadata {
+    width: number;
+    height: number;
+    channels: number;
+    channelFormat: TextureChannelFormat;
+    stringId: string;
+}
+export interface AudioMetadata {
+    stringId: string;
+    sampleRate: number;
+    channels: number;
+    durationMs: number;
+}
+export interface MeshGeometryInfo {
+    vertexCount: number;
+    indexCount: number;
+    hasNormals: number;
+    hasUvs: number;
+    compressedBufferOffset: number;
+    compressedBufferSize: number;
+    materialIndex: number;
+    positionMin?: [number, number, number];
+    positionMax?: [number, number, number];
+}
+export interface SceneNode {
+    name: string;
+    parentIndex: number;
+    position: [number, number, number];
+    rotation: [number, number, number, number];
+    scale: [number, number, number];
+    meshCount: number;
+    firstMeshIndex: number;
+}
+export interface MaterialPropertyValue {
+    fieldName: string;
+    value: [number, number, number, number];
+    textureId: string;
+}
+export interface MaterialData {
+    name: string;
+    schemaId: string;
+    propertyCount: number;
+    properties: MaterialPropertyValue[];
+}
+export interface MaterialSchemaField {
+    name: string;
+    fieldType: MaterialFieldType;
+    previewFlags: PreviewPropertyFlag;
+    defaultValue: [number, number, number, number];
+    defaultTextureId: string;
+}
+export interface MaterialSchemaMetadata {
+    stringId: string;
+    schemaName: string;
+    fieldCount: number;
+    fields: MaterialSchemaField[];
+}
+export interface MeshMetadata {
+    meshGeometryCount: number;
+    materialCount: number;
+    nodeCount: number;
+    stringId: string;
+    geometries: MeshGeometryInfo[];
+    materials: MaterialData[];
+    nodes: SceneNode[];
+    meshIndices: number[];
+}
+export interface SkinnedMeshGeometryInfo {
+    vertexCount: number;
+    indexCount: number;
+    hasNormals: number;
+    hasUvs: number;
+    vertexBufferOffset: number;
+    vertexBufferSize: number;
+    indexBufferOffset: number;
+    indexBufferSize: number;
+    weightsOffset: number;
+    weightsSize: number;
+    materialIndex: number;
+    _padding: number;
+}
+export interface Bone {
+    name: string;
+    parentIndex: number;
+    offsetMatrix: number[];
+}
+export interface VertexWeights {
+    boneIndices: [number, number, number, number];
+    weights: [number, number, number, number];
+}
+export interface SkinnedMeshMetadata {
+    meshGeometryCount: number;
+    materialCount: number;
+    nodeCount: number;
+    boneCount: number;
+    stringId: string;
+    geometries: SkinnedMeshGeometryInfo[];
+    materials: MaterialData[];
+    nodes: SceneNode[];
+    meshIndices: number[];
+    bones: Bone[];
+}
+export interface AnimationTrackDescriptor {
+    trackName: string;
+    keyframeCount: number;
+    valuesPerKey: number;
+    timesOffset: number;
+    valuesOffset: number;
+}
+export interface AnimationClipMetadata {
+    stringId: string;
+    targetMeshId: string;
+    metadataVersion: number;
+    duration: number;
+    trackCount: number;
+    tracks: AnimationTrackDescriptor[];
+}
+export interface AssetMetadataHeader {
+    tagCsvLength: number;
+}
+export interface PackerAsset {
+    canonicalPath: string;
+    type: AssetType;
+    uid: bigint;
+    data: Uint8Array;
+    metadata: Uint8Array | null;
+    tags: string[];
+}

package/dist/core/types.js

@@ -0,0 +1,76 @@
+// ─── Asset Type Enum ────────────────────────────────────────────────────────
+export var AssetType;
+(function (AssetType) {
+    AssetType[AssetType["Unknown"] = 0] = "Unknown";
+    AssetType[AssetType["StaticMesh"] = 1] = "StaticMesh";
+    AssetType[AssetType["Texture2D"] = 2] = "Texture2D";
+    AssetType[AssetType["Audio"] = 3] = "Audio";
+    AssetType[AssetType["MaterialSchema"] = 4] = "MaterialSchema";
+    AssetType[AssetType["SkinnedMesh"] = 5] = "SkinnedMesh";
+    AssetType[AssetType["AnimationClip"] = 6] = "AnimationClip";
+})(AssetType || (AssetType = {}));
+// ─── Texture Enums ──────────────────────────────────────────────────────────
+export var KTX2Quality;
+(function (KTX2Quality) {
+    KTX2Quality[KTX2Quality["Fastest"] = 0] = "Fastest";
+    KTX2Quality[KTX2Quality["Fast"] = 1] = "Fast";
+    KTX2Quality[KTX2Quality["Normal"] = 2] = "Normal";
+    KTX2Quality[KTX2Quality["High"] = 3] = "High";
+    KTX2Quality[KTX2Quality["Best"] = 4] = "Best";
+})(KTX2Quality || (KTX2Quality = {}));
+export var TextureChannelFormat;
+(function (TextureChannelFormat) {
+    TextureChannelFormat[TextureChannelFormat["Auto"] = 0] = "Auto";
+    TextureChannelFormat[TextureChannelFormat["RGB"] = 1] = "RGB";
+    TextureChannelFormat[TextureChannelFormat["RGBA"] = 2] = "RGBA";
+})(TextureChannelFormat || (TextureChannelFormat = {}));
+export var TextureResize;
+(function (TextureResize) {
+    TextureResize[TextureResize["Full"] = 0] = "Full";
+    TextureResize[TextureResize["Half"] = 1] = "Half";
+    TextureResize[TextureResize["Quarter"] = 2] = "Quarter";
+    TextureResize[TextureResize["Eighth"] = 3] = "Eighth";
+})(TextureResize || (TextureResize = {}));
+// ─── Material Enums ─────────────────────────────────────────────────────────
+export var MaterialFieldType;
+(function (MaterialFieldType) {
+    MaterialFieldType[MaterialFieldType["Texture"] = 0] = "Texture";
+    MaterialFieldType[MaterialFieldType["Color"] = 1] = "Color";
+    MaterialFieldType[MaterialFieldType["Float"] = 2] = "Float";
+    MaterialFieldType[MaterialFieldType["Vec2"] = 3] = "Vec2";
+    MaterialFieldType[MaterialFieldType["Vec3"] = 4] = "Vec3";
+    MaterialFieldType[MaterialFieldType["Vec4"] = 5] = "Vec4";
+    MaterialFieldType[MaterialFieldType["Int"] = 6] = "Int";
+})(MaterialFieldType || (MaterialFieldType = {}));
+export var PreviewPropertyFlag;
+(function (PreviewPropertyFlag) {
+    PreviewPropertyFlag[PreviewPropertyFlag["None"] = 0] = "None";
+    PreviewPropertyFlag[PreviewPropertyFlag["MainTex"] = 1] = "MainTex";
+    PreviewPropertyFlag[PreviewPropertyFlag["Tint"] = 2] = "Tint";
+    PreviewPropertyFlag[PreviewPropertyFlag["AlphaTest"] = 3] = "AlphaTest";
+})(PreviewPropertyFlag || (PreviewPropertyFlag = {}));
+// ─── Audio Enums ────────────────────────────────────────────────────────
+export var AacQuality;
+(function (AacQuality) {
+    AacQuality[AacQuality["Lowest"] = 0] = "Lowest";
+    AacQuality[AacQuality["Low"] = 1] = "Low";
+    AacQuality[AacQuality["Medium"] = 2] = "Medium";
+    AacQuality[AacQuality["High"] = 3] = "High";
+    AacQuality[AacQuality["Best"] = 4] = "Best";
+})(AacQuality || (AacQuality = {}));
+export var AudioSampleRate;
+(function (AudioSampleRate) {
+    AudioSampleRate[AudioSampleRate["Auto"] = 0] = "Auto";
+    AudioSampleRate[AudioSampleRate["Hz48000"] = 48000] = "Hz48000";
+    AudioSampleRate[AudioSampleRate["Hz44100"] = 44100] = "Hz44100";
+    AudioSampleRate[AudioSampleRate["Hz22050"] = 22050] = "Hz22050";
+    AudioSampleRate[AudioSampleRate["Hz11025"] = 11025] = "Hz11025";
+})(AudioSampleRate || (AudioSampleRate = {}));
+// ─── Mesh Enums ─────────────────────────────────────────────────────────────
+export var DracoQualityPreset;
+(function (DracoQualityPreset) {
+    DracoQualityPreset[DracoQualityPreset["Fast"] = 0] = "Fast";
+    DracoQualityPreset[DracoQualityPreset["Balanced"] = 1] = "Balanced";
+    DracoQualityPreset[DracoQualityPreset["HighQuality"] = 2] = "HighQuality";
+    DracoQualityPreset[DracoQualityPreset["MaximumQuality"] = 3] = "MaximumQuality";
+})(DracoQualityPreset || (DracoQualityPreset = {}));

package/dist/encoders/aac-encoder.d.ts

@@ -0,0 +1,12 @@
+import { AacQuality } from '../core/types.js';
+import type { IAacEncoder, IAudioDecoder, DecodedPcm } from './interfaces.js';
+export declare class NodeAacEncoder implements IAacEncoder {
+    private ffmpegPath;
+    initialize(): Promise<void>;
+    encode(channels: Float32Array[], sampleRate: number, quality: AacQuality): Promise<Uint8Array>;
+}
+export declare class NodeAudioDecoder implements IAudioDecoder {
+    private ffmpegPath;
+    initialize(): Promise<void>;
+    decodeToPcm(audioData: Uint8Array, _fileName: string): Promise<DecodedPcm>;
+}

package/dist/encoders/aac-encoder.js

@@ -0,0 +1,179 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { AacQuality } from '../core/types.js';
+const execFileAsync = promisify(execFile);
+// ─── Quality mapping ────────────────────────────────────────────────────────
+const QUALITY_TO_VBR = {
+    [AacQuality.Lowest]: '0.1',
+    [AacQuality.Low]: '0.25',
+    [AacQuality.Medium]: '0.4',
+    [AacQuality.High]: '0.8',
+    [AacQuality.Best]: '1.3',
+};
+// ─── WAV builder ─────────────────────────────────────────────────────────────
+function createWavBuffer(channels, sampleRate) {
+    const numChannels = channels.length;
+    const numSamples = channels[0].length;
+    const bytesPerSample = 4;
+    const dataSize = numSamples * numChannels * bytesPerSample;
+    const headerSize = 44;
+    const buffer = new ArrayBuffer(headerSize + dataSize);
+    const view = new DataView(buffer);
+    view.setUint32(0, 0x52494646, false); // "RIFF"
+    view.setUint32(4, 36 + dataSize, true);
+    view.setUint32(8, 0x57415645, false); // "WAVE"
+    view.setUint32(12, 0x666D7420, false); // "fmt "
+    view.setUint32(16, 16, true);
+    view.setUint16(20, 3, true); // IEEE float
+    view.setUint16(22, numChannels, true);
+    view.setUint32(24, sampleRate, true);
+    view.setUint32(28, sampleRate * numChannels * bytesPerSample, true);
+    view.setUint16(32, numChannels * bytesPerSample, true);
+    view.setUint16(34, 32, true);
+    view.setUint32(36, 0x64617461, false); // "data"
+    view.setUint32(40, dataSize, true);
+    let offset = headerSize;
+    for (let i = 0; i < numSamples; i++) {
+        for (let ch = 0; ch < numChannels; ch++) {
+            view.setFloat32(offset, channels[ch][i], true);
+            offset += 4;
+        }
+    }
+    return new Uint8Array(buffer);
+}
+// ─── Resolve ffmpeg binary ──────────────────────────────────────────────────
+async function getFfmpegPath() {
+    try {
+        // Try ffmpeg-static first
+        const mod = await import('ffmpeg-static');
+        const p = (mod.default ?? mod);
+        if (p)
+            return p;
+    }
+    catch {
+        // Fallback to PATH
+    }
+    return 'ffmpeg';
+}
+// ─── NodeAacEncoder ─────────────────────────────────────────────────────────
+export class NodeAacEncoder {
+    ffmpegPath = null;
+    async initialize() {
+        this.ffmpegPath = await getFfmpegPath();
+    }
+    async encode(channels, sampleRate, quality) {
+        if (!this.ffmpegPath)
+            await this.initialize();
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'stowkit-'));
+        const inFile = path.join(tmpDir, 'in.wav');
+        const outFile = path.join(tmpDir, 'out.m4a');
+        try {
+            const wavBytes = createWavBuffer(channels, sampleRate);
+            await fs.writeFile(inFile, wavBytes);
+            const vbr = QUALITY_TO_VBR[quality];
+            await execFileAsync(this.ffmpegPath, [
+                '-y',
+                '-i', inFile,
+                '-c:a', 'aac',
+                '-q:a', vbr,
+                outFile,
+            ]);
+            const result = await fs.readFile(outFile);
+            return new Uint8Array(result.buffer, result.byteOffset, result.byteLength);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => { });
+        }
+    }
+}
+// ─── NodeAudioDecoder ───────────────────────────────────────────────────────
+export class NodeAudioDecoder {
+    ffmpegPath = null;
+    async initialize() {
+        this.ffmpegPath = await getFfmpegPath();
+    }
+    async decodeToPcm(audioData, _fileName) {
+        if (!this.ffmpegPath)
+            await this.initialize();
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'stowkit-'));
+        const inFile = path.join(tmpDir, 'input');
+        const outFile = path.join(tmpDir, 'output.raw');
+        try {
+            await fs.writeFile(inFile, audioData);
+            // First, get audio info
+            const { stdout } = await execFileAsync(this.ffmpegPath, [
+                '-i', inFile,
+                '-hide_banner',
+            ], { encoding: 'utf-8' }).catch(e => {
+                // ffmpeg exits non-zero when only probing, but prints info to stderr
+                return { stdout: '', stderr: e.stderr ?? '' };
+            });
+            const infoText = stdout || '';
+            // Parse sample rate and channels from ffmpeg output
+            const sampleRateMatch = infoText.match(/(\d+) Hz/);
+            const channelsMatch = infoText.match(/(\d+) channels/) || infoText.match(/(mono|stereo)/i);
+            // Use ffprobe-style approach: decode to raw PCM f32le
+            await execFileAsync(this.ffmpegPath, [
+                '-y',
+                '-i', inFile,
+                '-f', 'f32le',
+                '-acodec', 'pcm_f32le',
+                outFile,
+            ]);
+            // Get the actual sample rate and channel count via a second pass
+            const probeResult = await execFileAsync(this.ffmpegPath, [
+                '-i', inFile,
+                '-show_entries', 'stream=sample_rate,channels',
+                '-of', 'json',
+                '-v', 'quiet',
+            ]).catch(() => null);
+            let sampleRate = 44100;
+            let numChannels = 2;
+            if (probeResult) {
+                try {
+                    const info = JSON.parse(probeResult.stdout);
+                    if (info.streams?.[0]) {
+                        sampleRate = parseInt(info.streams[0].sample_rate) || 44100;
+                        numChannels = info.streams[0].channels || 2;
+                    }
+                }
+                catch {
+                    // Use ffmpeg stderr parsing fallback
+                    if (sampleRateMatch)
+                        sampleRate = parseInt(sampleRateMatch[1]);
+                    if (channelsMatch) {
+                        if (channelsMatch[1] === 'mono')
+                            numChannels = 1;
+                        else if (channelsMatch[1] === 'stereo')
+                            numChannels = 2;
+                        else
+                            numChannels = parseInt(channelsMatch[1]) || 2;
+                    }
+                }
+            }
+            const rawBuf = await fs.readFile(outFile);
+            const rawF32 = new Float32Array(rawBuf.buffer, rawBuf.byteOffset, rawBuf.byteLength / 4);
+            const numSamples = Math.floor(rawF32.length / numChannels);
+            // Deinterleave
+            const channels = [];
+            for (let ch = 0; ch < numChannels; ch++) {
+                const channelData = new Float32Array(numSamples);
+                for (let i = 0; i < numSamples; i++) {
+                    channelData[i] = rawF32[i * numChannels + ch];
+                }
+                channels.push(channelData);
+            }
+            return {
+                channels,
+                sampleRate,
+                durationMs: Math.round((numSamples / sampleRate) * 1000),
+            };
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => { });
+        }
+    }
+}

package/dist/encoders/basis-encoder.d.ts

@@ -0,0 +1,15 @@
+import type { ITextureEncoder, TextureEncodeResult } from './interfaces.js';
+import { KTX2Quality, TextureChannelFormat } from '../core/types.js';
+/**
+ * Node.js Basis Universal texture encoder.
+ * Loads the Basis WASM encoder from the stowkit-packer-gui/public/wasm/ directory.
+ */
+export declare class NodeBasisEncoder implements ITextureEncoder {
+    private basis;
+    private ready;
+    private wasmDir;
+    constructor(wasmDir?: string);
+    isReady(): boolean;
+    initialize(): Promise<void>;
+    encode(pixels: Uint8Array, width: number, height: number, channels: number, quality: KTX2Quality, channelFormat: TextureChannelFormat, generateMipmaps?: boolean): Promise<TextureEncodeResult>;
+}

package/dist/encoders/basis-encoder.js

@@ -0,0 +1,116 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+import { KTX2Quality, TextureChannelFormat } from '../core/types.js';
+const QUALITY_TO_LEVEL = {
+    [KTX2Quality.Fastest]: 1,
+    [KTX2Quality.Fast]: 64,
+    [KTX2Quality.Normal]: 128,
+    [KTX2Quality.High]: 192,
+    [KTX2Quality.Best]: 255,
+};
+function hasAlpha(rgba, pixelCount) {
+    for (let i = 0; i < pixelCount; i++) {
+        if (rgba[i * 4 + 3] < 255)
+            return true;
+    }
+    return false;
+}
+function rgbToRgba(rgb, pixelCount) {
+    const rgba = new Uint8Array(pixelCount * 4);
+    for (let i = 0; i < pixelCount; i++) {
+        rgba[i * 4] = rgb[i * 3];
+        rgba[i * 4 + 1] = rgb[i * 3 + 1];
+        rgba[i * 4 + 2] = rgb[i * 3 + 2];
+        rgba[i * 4 + 3] = 255;
+    }
+    return rgba;
+}
+/**
+ * Node.js Basis Universal texture encoder.
+ * Loads the Basis WASM encoder from the stowkit-packer-gui/public/wasm/ directory.
+ */
+export class NodeBasisEncoder {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    basis = null;
+    ready = false;
+    wasmDir;
+    constructor(wasmDir) {
+        // Default: look for wasm files in stowkit-packer-gui/public/wasm/ relative to monorepo root
+        this.wasmDir = wasmDir ?? path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../stowkit-packer-gui/public/wasm');
+    }
+    isReady() {
+        return this.ready;
+    }
+    async initialize() {
+        const jsPath = path.join(this.wasmDir, 'basis_encoder.js');
+        const jsSource = fs.readFileSync(jsPath, 'utf-8');
+        // The basis_encoder.js glue expects CJS globals. Provide them in our ESM context.
+        const nodeRequire = createRequire(jsPath);
+        const fn = new Function('require', '__dirname', '__filename', 'module', 'exports', jsSource + '\nreturn typeof BASIS !== "undefined" ? BASIS : globalThis.BASIS;');
+        const moduleShim = { exports: {} };
+        const BASIS = fn(nodeRequire, this.wasmDir, jsPath, moduleShim, moduleShim.exports);
+        if (!BASIS || typeof BASIS !== 'function') {
+            throw new Error('BASIS factory not found in basis_encoder.js');
+        }
+        this.basis = await BASIS({
+            locateFile: (f) => path.join(this.wasmDir, f),
+        });
+        this.basis.initializeBasis();
+        this.ready = true;
+    }
+    async encode(pixels, width, height, channels, quality, channelFormat, generateMipmaps = false) {
+        if (!this.basis || !this.ready) {
+            throw new Error('Basis encoder not initialized');
+        }
+        const pixelCount = width * height;
+        const rgba = channels === 3 ? rgbToRgba(pixels, pixelCount) :
+            channels === 4 ? pixels :
+                (() => { throw new Error(`Unsupported channel count: ${channels}`); })();
+        const useUastc = channelFormat === TextureChannelFormat.RGBA ||
+            (channelFormat === TextureChannelFormat.Auto &&
+                channels === 4 &&
+                hasAlpha(rgba, pixelCount));
+        const enc = new this.basis.BasisEncoder();
+        try {
+            enc.setSliceSourceImage(0, rgba, width, height, false);
+            enc.setCreateKTX2File(true);
+            enc.setPerceptual(true);
+            enc.setMipGen(generateMipmaps);
+            enc.setUASTC(useUastc);
+            enc.setCheckForAlpha(useUastc);
+            if (useUastc) {
+                if (typeof enc.setPackUASTCFlags === 'function') {
+                    enc.setPackUASTCFlags(quality);
+                }
+                enc.setKTX2UASTCSupercompression(true);
+            }
+            else {
+                enc.setQualityLevel(QUALITY_TO_LEVEL[quality]);
+                enc.setKTX2UASTCSupercompression(false);
+                if (typeof enc.setNoSelectorRDO === 'function')
+                    enc.setNoSelectorRDO(true);
+                if (typeof enc.setNoEndpointRDO === 'function')
+                    enc.setNoEndpointRDO(true);
+            }
+            const maxSize = width * height * 4 + 1048576;
+            const dst = new Uint8Array(maxSize);
+            const n = enc.encode(dst);
+            if (n === 0)
+                throw new Error('Basis encoding returned 0 bytes');
+            const ktx2Data = dst.slice(0, n);
+            const metadata = {
+                width,
+                height,
+                channels: useUastc ? 4 : 3,
+                channelFormat: useUastc ? TextureChannelFormat.RGBA : TextureChannelFormat.RGB,
+                stringId: '',
+            };
+            return { data: ktx2Data, metadata };
+        }
+        finally {
+            enc.delete();
+        }
+    }
+}

package/dist/encoders/draco-encoder.d.ts

@@ -0,0 +1,11 @@
+import type { IMeshEncoder, MeshEncodeSettings, MeshEncodeResult, ImportedMesh } from './interfaces.js';
+import { DracoQualityPreset } from '../core/types.js';
+export declare function dracoPresetToSettings(preset: DracoQualityPreset): MeshEncodeSettings;
+export declare class NodeDracoEncoder implements IMeshEncoder {
+    private draco;
+    private ready;
+    isReady(): boolean;
+    initialize(): Promise<void>;
+    encode(mesh: ImportedMesh, settings: MeshEncodeSettings): Promise<MeshEncodeResult>;
+    private encodeSubMesh;
+}