threlte-mcp 1.4.0

package/dist/client/MCPBridge.svelte

@@ -0,0 +1,59 @@
+<!--
+  MCPBridge Svelte Component
+  
+  Drop-in component that initializes the MCP bridge for your Threlte app.
+  Auto-connects in development mode.
+  
+  @example
+  ```svelte
+  <script>
+    import { MCPBridge } from 'threlte-mcp/client';
+  </script>
+  
+  <MCPBridge />
+  ```
+-->
+<script lang="ts">
+    import { useThrelte } from "@threlte/core";
+    import { onMount, onDestroy } from "svelte";
+    import {
+        MCPBridge as Bridge,
+        getMCPBridge,
+        type MCPBridgeOptions,
+    } from "./MCPBridge.js";
+
+    interface Props {
+        /** Custom WebSocket URL (default: ws://127.0.0.1:8082) */
+        url?: string;
+        /** Force enable/disable (default: auto in dev mode) */
+        enabled?: boolean;
+        /** Reconnect delay in ms (default: 60000) */
+        reconnectDelay?: number;
+    }
+
+    let { url, enabled, reconnectDelay }: Props = $props();
+
+    const { scene } = useThrelte();
+    let bridge: Bridge | null = null;
+
+    onMount(() => {
+        if (scene) {
+            const options: MCPBridgeOptions = {
+                url,
+                reconnectDelay,
+                autoConnect: enabled,
+            };
+
+            bridge = getMCPBridge(scene) || new Bridge(scene, options);
+            console.log('[MCPBridge] Component initialized');
+        }
+    });
+
+    onDestroy(() => {
+        bridge?.disconnect();
+        console.log('[MCPBridge] Component destroyed');
+    });
+</script>
+
+<!-- No visible UI - this is a logic-only component -->
+

package/dist/client/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * threlte-mcp Client Package
+ *
+ * Client-side bridge for connecting Threlte/Three.js apps to the MCP server.
+ *
+ * @example
+ * ```typescript
+ * // Option 1: Import the class directly
+ * import { MCPBridge } from 'threlte-mcp/client';
+ * const bridge = new MCPBridge(scene);
+ *
+ * // Option 2: Use the Svelte component
+ * import MCPBridgeComponent from 'threlte-mcp/client/MCPBridge.svelte';
+ * ```
+ */
+export { MCPBridge, getMCPBridge, type MCPBridgeOptions } from './MCPBridge.js';
+export { default as MCPBridgeComponent } from './MCPBridge.svelte';
+//# sourceMappingURL=index.d.ts.map

package/dist/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../client/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,KAAK,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAChF,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/client/index.js

@@ -0,0 +1,18 @@
+/**
+ * threlte-mcp Client Package
+ *
+ * Client-side bridge for connecting Threlte/Three.js apps to the MCP server.
+ *
+ * @example
+ * ```typescript
+ * // Option 1: Import the class directly
+ * import { MCPBridge } from 'threlte-mcp/client';
+ * const bridge = new MCPBridge(scene);
+ *
+ * // Option 2: Use the Svelte component
+ * import MCPBridgeComponent from 'threlte-mcp/client/MCPBridge.svelte';
+ * ```
+ */
+export { MCPBridge, getMCPBridge } from './MCPBridge.js';
+export { default as MCPBridgeComponent } from './MCPBridge.svelte';
+//# sourceMappingURL=index.js.map

package/dist/client/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../client/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,SAAS,EAAE,YAAY,EAAyB,MAAM,gBAAgB,CAAC;AAChF,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/gltf-io.d.ts

@@ -0,0 +1,11 @@
+import { type Document } from '@gltf-transform/core';
+export interface GltfDocumentLoadResult {
+    document: Document;
+    resolvedPath: string;
+    bytes: number;
+}
+export declare function resolveAssetPath(input: string): string;
+export declare function resolveOutputPath(inputPath: string, outputPath?: string, suffix?: string): string;
+export declare function loadGltfDocument(assetPath: string): Promise<GltfDocumentLoadResult>;
+export declare function writeGltfDocument(document: Document, outputPath: string): Promise<number>;
+//# sourceMappingURL=gltf-io.d.ts.map

package/dist/gltf-io.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-io.d.ts","sourceRoot":"","sources":["../src/gltf-io.ts"],"names":[],"mappings":"AAGA,OAAO,EAAU,KAAK,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAK7D,MAAM,WAAW,sBAAsB;IACnC,QAAQ,EAAE,QAAQ,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;CACjB;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAUtD;AAED,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,MAAM,SAAe,GAAG,MAAM,CAevG;AAED,wBAAsB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,sBAAsB,CAAC,CA8BzF;AAED,wBAAsB,iBAAiB,CAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAK/F"}

package/dist/gltf-io.js

@@ -0,0 +1,64 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { NodeIO } from '@gltf-transform/core';
+const io = new NodeIO();
+const SUPPORTED_EXTENSIONS = new Set(['.gltf', '.glb']);
+export function resolveAssetPath(input) {
+    if (/^https?:\/\//i.test(input)) {
+        throw new Error('Remote URLs are not supported. Provide a local file path or file:// URL.');
+    }
+    if (input.startsWith('file://')) {
+        return fileURLToPath(input);
+    }
+    return path.normalize(input);
+}
+export function resolveOutputPath(inputPath, outputPath, suffix = '-optimized') {
+    if (outputPath) {
+        const resolvedOutput = resolveAssetPath(outputPath);
+        const extension = path.extname(resolvedOutput);
+        if (extension) {
+            return resolvedOutput;
+        }
+        const inputExtension = path.extname(inputPath) || '.glb';
+        return `${resolvedOutput}${inputExtension}`;
+    }
+    const extension = path.extname(inputPath);
+    const baseName = path.basename(inputPath, extension);
+    const dirName = path.dirname(inputPath);
+    return path.join(dirName, `${baseName}${suffix}${extension || '.glb'}`);
+}
+export async function loadGltfDocument(assetPath) {
+    if (!assetPath || typeof assetPath !== 'string') {
+        throw new Error('path is required');
+    }
+    const resolvedPath = resolveAssetPath(assetPath);
+    const extension = path.extname(resolvedPath).toLowerCase();
+    if (!SUPPORTED_EXTENSIONS.has(extension)) {
+        throw new Error(`Unsupported extension "${extension}". Expected .gltf or .glb.`);
+    }
+    let stat;
+    try {
+        stat = await fs.stat(resolvedPath);
+    }
+    catch {
+        throw new Error(`File not found: ${resolvedPath}`);
+    }
+    if (!stat.isFile()) {
+        throw new Error(`Not a file: ${resolvedPath}`);
+    }
+    try {
+        const document = await io.read(resolvedPath);
+        return { document, resolvedPath, bytes: stat.size };
+    }
+    catch (error) {
+        throw new Error(`Failed to read glTF: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export async function writeGltfDocument(document, outputPath) {
+    const resolvedOutput = resolveAssetPath(outputPath);
+    await io.write(resolvedOutput, document);
+    const stat = await fs.stat(resolvedOutput);
+    return stat.size;
+}
+//# sourceMappingURL=gltf-io.js.map

package/dist/gltf-io.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-io.js","sourceRoot":"","sources":["../src/gltf-io.ts"],"names":[],"mappings":"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"}

package/dist/gltf-tools.d.ts

@@ -0,0 +1,120 @@
+export interface GltfMeshPrimitiveSummary {
+    mode: string;
+    vertices: number;
+    triangles: number;
+    attributes: string[];
+}
+export interface GltfMeshSummary {
+    name: string | null;
+    primitiveCount: number;
+    estimatedVertices: number;
+    estimatedTriangles: number;
+    attributes: string[];
+    primitives: GltfMeshPrimitiveSummary[];
+}
+export interface GltfSceneSummary {
+    name: string | null;
+    nodeCount: number;
+}
+export interface GltfMaterialSummary {
+    name: string | null;
+    alphaMode: string;
+    doubleSided: boolean;
+}
+export interface GltfTextureSummary {
+    name: string | null;
+    mimeType: string | null;
+}
+export interface GltfAnimationSummary {
+    name: string | null;
+    channels: number;
+    samplers: number;
+}
+export interface GltfAnalysisSummary {
+    scenes: number;
+    nodes: number;
+    meshes: number;
+    materials: number;
+    textures: number;
+    animations: number;
+    skins: number;
+    drawCalls: number;
+    estimatedVertices: number;
+    estimatedTriangles: number;
+}
+export interface GltfAnalysis {
+    source: {
+        path: string;
+        bytes: number;
+    };
+    summary: GltfAnalysisSummary;
+    scenes: GltfSceneSummary[];
+    meshes: GltfMeshSummary[];
+    materials: GltfMaterialSummary[];
+    textures: GltfTextureSummary[];
+    animations: GltfAnimationSummary[];
+    inspection: unknown | null;
+}
+export interface GltfValidationLimits {
+    maxDrawCalls: number;
+    maxTriangles: number;
+    maxVertices: number;
+    maxTextures: number;
+    maxMaterials: number;
+    maxAnimations: number;
+}
+export interface GltfValidationReport {
+    source: {
+        path: string;
+        bytes: number;
+    };
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+    metrics: GltfAnalysisSummary;
+    limits: GltfValidationLimits;
+    issues: {
+        missingPosition: string[];
+    };
+    inspection: unknown | null;
+}
+export interface GltfOptimizationSimplifyOptions {
+    ratio?: number;
+    error?: number;
+    lockBorder?: boolean;
+}
+export interface GltfOptimizationTextureOptions {
+    format?: 'jpeg' | 'png' | 'webp' | 'avif';
+    resize?: [number, number] | 'nearest-pot' | 'ceil-pot' | 'floor-pot';
+    quality?: number;
+    useSharp?: boolean;
+}
+export interface GltfOptimizationOptions {
+    outputPath?: string;
+    dedup?: boolean;
+    prune?: boolean;
+    weld?: boolean;
+    quantize?: boolean;
+    simplify?: GltfOptimizationSimplifyOptions;
+    textures?: GltfOptimizationTextureOptions;
+}
+export interface GltfOptimizationReport {
+    source: {
+        path: string;
+        bytes: number;
+    };
+    output: {
+        path: string;
+        bytes: number;
+        bytesSaved: number;
+        percentSaved: number;
+    };
+    actions: string[];
+    warnings: string[];
+    summary: GltfAnalysisSummary;
+    inspection: unknown | null;
+}
+export declare function analyzeGltf(assetPath: string): Promise<GltfAnalysis>;
+export declare function validateGltf(assetPath: string, limits?: Partial<GltfValidationLimits>): Promise<GltfValidationReport>;
+export declare function optimizeGltf(assetPath: string, options?: GltfOptimizationOptions): Promise<GltfOptimizationReport>;
+//# sourceMappingURL=gltf-tools.d.ts.map

package/dist/gltf-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-tools.d.ts","sourceRoot":"","sources":["../src/gltf-tools.ts"],"names":[],"mappings":"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"}

package/dist/gltf-tools.js

@@ -0,0 +1,360 @@
+import { dedup, inspect, prune, quantize, simplify, textureCompress, weld } from '@gltf-transform/functions';
+import { loadGltfDocument, resolveOutputPath, writeGltfDocument } from './gltf-io.js';
+const KNOWN_ATTRIBUTES = [
+    'POSITION',
+    'NORMAL',
+    'TANGENT',
+    'TEXCOORD_0',
+    'TEXCOORD_1',
+    'COLOR_0',
+    'JOINTS_0',
+    'WEIGHTS_0',
+];
+const MODE_LABELS = {
+    0: 'POINTS',
+    1: 'LINES',
+    2: 'LINE_LOOP',
+    3: 'LINE_STRIP',
+    4: 'TRIANGLES',
+    5: 'TRIANGLE_STRIP',
+    6: 'TRIANGLE_FAN',
+};
+const DEFAULT_LIMITS = {
+    maxDrawCalls: 200,
+    maxTriangles: 200_000,
+    maxVertices: 400_000,
+    maxTextures: 12,
+    maxMaterials: 50,
+    maxAnimations: 200,
+};
+function normalizeName(name) {
+    const trimmed = name?.trim();
+    return trimmed ? trimmed : null;
+}
+function countSceneNodes(scene) {
+    let count = 0;
+    const visit = (node) => {
+        count += 1;
+        for (const child of node.listChildren()) {
+            visit(child);
+        }
+    };
+    for (const child of scene.listChildren()) {
+        visit(child);
+    }
+    return count;
+}
+function estimateTriangles(primitive, vertexCount, indexCount) {
+    const mode = primitive.getMode();
+    const count = indexCount > 0 ? indexCount : vertexCount;
+    if (mode === 4) {
+        return Math.floor(count / 3);
+    }
+    if (mode === 5 || mode === 6) {
+        return Math.max(0, count - 2);
+    }
+    return 0;
+}
+function collectMeshSummaries(document) {
+    const root = document.getRoot();
+    const meshes = root.listMeshes();
+    const missingPosition = [];
+    let totalPrimitives = 0;
+    let totalVertices = 0;
+    let totalTriangles = 0;
+    const meshSummaries = meshes.map((mesh, meshIndex) => {
+        const meshName = normalizeName(mesh.getName());
+        const meshLabel = meshName ?? `mesh_${meshIndex}`;
+        const primitives = mesh.listPrimitives();
+        const primitiveSummaries = primitives.map((primitive, primitiveIndex) => {
+            const position = primitive.getAttribute('POSITION');
+            if (!position) {
+                missingPosition.push(`${meshLabel}:primitive_${primitiveIndex}`);
+            }
+            const vertexCount = position ? position.getCount() : 0;
+            const indices = primitive.getIndices();
+            const indexCount = indices ? indices.getCount() : 0;
+            const triangleCount = estimateTriangles(primitive, vertexCount, indexCount);
+            const attributes = KNOWN_ATTRIBUTES.filter((attribute) => primitive.getAttribute(attribute) !== null);
+            const modeValue = primitive.getMode();
+            const mode = MODE_LABELS[modeValue] ?? `MODE_${modeValue}`;
+            totalPrimitives += 1;
+            totalVertices += vertexCount;
+            totalTriangles += triangleCount;
+            return {
+                mode,
+                vertices: vertexCount,
+                triangles: triangleCount,
+                attributes,
+            };
+        });
+        const attributes = Array.from(new Set(primitiveSummaries.flatMap((summary) => summary.attributes)));
+        const meshVertices = primitiveSummaries.reduce((sum, summary) => sum + summary.vertices, 0);
+        const meshTriangles = primitiveSummaries.reduce((sum, summary) => sum + summary.triangles, 0);
+        return {
+            name: meshName,
+            primitiveCount: primitives.length,
+            estimatedVertices: meshVertices,
+            estimatedTriangles: meshTriangles,
+            attributes,
+            primitives: primitiveSummaries,
+        };
+    });
+    return {
+        meshSummaries,
+        totalPrimitives,
+        totalVertices,
+        totalTriangles,
+        missingPosition,
+    };
+}
+function normalizeLimits(limits) {
+    if (!limits) {
+        return { ...DEFAULT_LIMITS };
+    }
+    const sanitized = Object.fromEntries(Object.entries(limits).filter(([, value]) => typeof value === 'number' && Number.isFinite(value)));
+    return {
+        ...DEFAULT_LIMITS,
+        ...sanitized,
+    };
+}
+async function safeInspect(document) {
+    try {
+        const result = inspect(document);
+        if (result && typeof result.then === 'function') {
+            return await result;
+        }
+        return result;
+    }
+    catch {
+        return null;
+    }
+}
+async function buildAnalysis(document, resolvedPath, bytes) {
+    const root = document.getRoot();
+    const { meshSummaries, totalPrimitives, totalVertices, totalTriangles, missingPosition } = collectMeshSummaries(document);
+    const scenes = root.listScenes().map((scene) => ({
+        name: normalizeName(scene.getName()),
+        nodeCount: countSceneNodes(scene),
+    }));
+    const materials = root.listMaterials().map((material) => ({
+        name: normalizeName(material.getName()),
+        alphaMode: material.getAlphaMode(),
+        doubleSided: material.getDoubleSided(),
+    }));
+    const textures = root.listTextures().map((texture) => ({
+        name: normalizeName(texture.getName()),
+        mimeType: texture.getMimeType(),
+    }));
+    const animations = root.listAnimations().map((animation) => ({
+        name: normalizeName(animation.getName()),
+        channels: animation.listChannels().length,
+        samplers: animation.listSamplers().length,
+    }));
+    const summary = {
+        scenes: scenes.length,
+        nodes: root.listNodes().length,
+        meshes: meshSummaries.length,
+        materials: materials.length,
+        textures: textures.length,
+        animations: animations.length,
+        skins: root.listSkins().length,
+        drawCalls: totalPrimitives,
+        estimatedVertices: totalVertices,
+        estimatedTriangles: totalTriangles,
+    };
+    const analysis = {
+        source: {
+            path: resolvedPath,
+            bytes,
+        },
+        summary,
+        scenes,
+        meshes: meshSummaries,
+        materials,
+        textures,
+        animations,
+        inspection: await safeInspect(document),
+    };
+    return { analysis, missingPosition };
+}
+export async function analyzeGltf(assetPath) {
+    const { document, resolvedPath, bytes } = await loadGltfDocument(assetPath);
+    return (await buildAnalysis(document, resolvedPath, bytes)).analysis;
+}
+export async function validateGltf(assetPath, limits) {
+    const { document, resolvedPath, bytes } = await loadGltfDocument(assetPath);
+    const { analysis, missingPosition } = await buildAnalysis(document, resolvedPath, bytes);
+    const normalizedLimits = normalizeLimits(limits);
+    const errors = [];
+    const warnings = [];
+    if (analysis.summary.scenes === 0) {
+        errors.push('No scenes found.');
+    }
+    if (analysis.summary.meshes === 0) {
+        warnings.push('No meshes found.');
+    }
+    if (missingPosition.length > 0) {
+        errors.push(`Missing POSITION attribute in ${missingPosition.length} primitive(s).`);
+    }
+    if (analysis.summary.drawCalls > normalizedLimits.maxDrawCalls) {
+        warnings.push(`High draw call count (${analysis.summary.drawCalls}). Target <= ${normalizedLimits.maxDrawCalls}.`);
+    }
+    if (analysis.summary.estimatedTriangles > normalizedLimits.maxTriangles) {
+        warnings.push(`High triangle count (${analysis.summary.estimatedTriangles}). Target <= ${normalizedLimits.maxTriangles}.`);
+    }
+    if (analysis.summary.estimatedVertices > normalizedLimits.maxVertices) {
+        warnings.push(`High vertex count (${analysis.summary.estimatedVertices}). Target <= ${normalizedLimits.maxVertices}.`);
+    }
+    if (analysis.summary.textures > normalizedLimits.maxTextures) {
+        warnings.push(`High texture count (${analysis.summary.textures}). Target <= ${normalizedLimits.maxTextures}.`);
+    }
+    if (analysis.summary.materials > normalizedLimits.maxMaterials) {
+        warnings.push(`High material count (${analysis.summary.materials}). Target <= ${normalizedLimits.maxMaterials}.`);
+    }
+    if (analysis.summary.animations > normalizedLimits.maxAnimations) {
+        warnings.push(`High animation count (${analysis.summary.animations}). Target <= ${normalizedLimits.maxAnimations}.`);
+    }
+    return {
+        source: {
+            path: resolvedPath,
+            bytes,
+        },
+        valid: errors.length === 0,
+        errors,
+        warnings,
+        metrics: analysis.summary,
+        limits: normalizedLimits,
+        issues: {
+            missingPosition,
+        },
+        inspection: analysis.inspection,
+    };
+}
+async function loadMeshoptSimplifier(warnings) {
+    try {
+        const module = await import('meshoptimizer');
+        const simplifier = module.MeshoptSimplifier ?? module.default?.MeshoptSimplifier;
+        if (!simplifier) {
+            warnings.push('Meshoptimizer simplifier not available. Skipping simplify.');
+            return null;
+        }
+        if ('ready' in simplifier && typeof simplifier.ready?.then === 'function') {
+            await simplifier.ready;
+        }
+        return simplifier;
+    }
+    catch (error) {
+        warnings.push(`Meshoptimizer not available. Skipping simplify. (${error instanceof Error ? error.message : String(error)})`);
+        return null;
+    }
+}
+async function loadSharpEncoder(warnings) {
+    try {
+        const module = await import('sharp');
+        return module.default ?? module;
+    }
+    catch (error) {
+        warnings.push(`Sharp encoder not available. Texture compression will use fallback. (${error instanceof Error ? error.message : String(error)})`);
+        return null;
+    }
+}
+export async function optimizeGltf(assetPath, options = {}) {
+    const { document, resolvedPath, bytes } = await loadGltfDocument(assetPath);
+    const outputPath = resolveOutputPath(resolvedPath, options.outputPath);
+    const actions = [];
+    const warnings = [];
+    const transforms = [];
+    const dedupEnabled = options.dedup ?? true;
+    if (dedupEnabled) {
+        transforms.push(dedup());
+        actions.push('dedup');
+    }
+    const weldEnabled = options.weld ?? true;
+    if (weldEnabled) {
+        transforms.push(weld());
+        actions.push('weld');
+    }
+    const quantizeEnabled = options.quantize ?? true;
+    if (quantizeEnabled) {
+        transforms.push(quantize());
+        actions.push('quantize');
+    }
+    if (options.simplify) {
+        const ratio = options.simplify.ratio ?? 0.75;
+        const error = options.simplify.error ?? 0.001;
+        const lockBorder = options.simplify.lockBorder ?? false;
+        if (ratio <= 0 || ratio >= 1) {
+            warnings.push('Simplify ratio must be between 0 and 1. Skipping simplify.');
+        }
+        else {
+            const simplifier = await loadMeshoptSimplifier(warnings);
+            if (simplifier) {
+                transforms.push(simplify({ simplifier, ratio, error, lockBorder }));
+                actions.push(`simplify(ratio=${ratio},error=${error})`);
+            }
+        }
+    }
+    const pruneEnabled = options.prune ?? true;
+    if (pruneEnabled) {
+        transforms.push(prune());
+        actions.push('prune');
+    }
+    const textures = options.textures;
+    if (textures) {
+        const root = document.getRoot();
+        if (root.listTextures().length === 0) {
+            warnings.push('No textures found to compress.');
+        }
+        else {
+            let resizeOption;
+            if (Array.isArray(textures.resize)) {
+                if (textures.resize.length === 2 &&
+                    textures.resize.every((value) => typeof value === 'number' && Number.isFinite(value))) {
+                    resizeOption = [textures.resize[0], textures.resize[1]];
+                }
+                else {
+                    warnings.push('Texture resize must be a [width, height] array.');
+                }
+            }
+            else if (typeof textures.resize === 'string') {
+                resizeOption = textures.resize;
+            }
+            let encoder;
+            if (textures.useSharp) {
+                encoder = await loadSharpEncoder(warnings) ?? undefined;
+            }
+            transforms.push(textureCompress({
+                encoder,
+                targetFormat: textures.format,
+                resize: resizeOption,
+                quality: textures.quality,
+            }));
+            actions.push('textureCompress');
+        }
+    }
+    if (transforms.length > 0) {
+        await document.transform(...transforms);
+    }
+    const outputBytes = await writeGltfDocument(document, outputPath);
+    const bytesSaved = Math.max(0, bytes - outputBytes);
+    const percentSaved = bytes > 0 ? Math.round((bytesSaved / bytes) * 10000) / 100 : 0;
+    const { analysis } = await buildAnalysis(document, outputPath, outputBytes);
+    return {
+        source: {
+            path: resolvedPath,
+            bytes,
+        },
+        output: {
+            path: outputPath,
+            bytes: outputBytes,
+            bytesSaved,
+            percentSaved,
+        },
+        actions,
+        warnings,
+        summary: analysis.summary,
+        inspection: analysis.inspection,
+    };
+}
+//# sourceMappingURL=gltf-tools.js.map