@needle-tools/gltf-build-pipeline 2.13.0 → 2.13.1

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-export * from "./config/index.js";
-export * from "./cli/index.js";
-export * from "./utils/index.js";
-export * from "./transforms/index.js";
-export * from "./extensions/index.js";
-export * from "./cache/index.js";
-export * from "./scripts/index.js";
-export * from "./constants.js";
+export * from "./config/index.js";
+export * from "./cli/index.js";
+export * from "./utils/index.js";
+export * from "./transforms/index.js";
+export * from "./extensions/index.js";
+export * from "./cache/index.js";
+export * from "./scripts/index.js";
+export * from "./constants.js";

package/dist/index.js

@@ -1,8 +1,8 @@
-export * from "./config/index.js";
-export * from "./cli/index.js";
-export * from "./utils/index.js";
-export * from "./transforms/index.js";
-export * from "./extensions/index.js";
-export * from "./cache/index.js";
-export * from "./scripts/index.js";
-export * from "./constants.js";
+export * from "./config/index.js";
+export * from "./cli/index.js";
+export * from "./utils/index.js";
+export * from "./transforms/index.js";
+export * from "./extensions/index.js";
+export * from "./cache/index.js";
+export * from "./scripts/index.js";
+export * from "./constants.js";

package/dist/scripts/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./pack-gltf.js";
-export * from "./stats.js";
+export * from "./pack-gltf.js";
+export * from "./stats.js";

package/dist/scripts/index.js

@@ -1,2 +1,2 @@
-export * from "./pack-gltf.js";
-export * from "./stats.js";
+export * from "./pack-gltf.js";
+export * from "./stats.js";

package/dist/scripts/pack-gltf.d.ts

@@ -1,15 +1,15 @@
-import { ILogger } from '@gltf-transform/core';
-import { ProcessStats } from "../utils/index.js";
-import { Config } from '../config/index.js';
-export type PackGLTFOptions = {
-    useCache: boolean;
-    packedFiles?: Set<string>;
-    stats?: ProcessStats;
-    config: Config;
-    logger?: ILogger;
-    debug: boolean;
-    verbose?: boolean;
-};
-/** Compress a glTF file
- */
-export declare function packGLTF(inputFile: string, outputFile: string, options: PackGLTFOptions): Promise<boolean>;
+import { ILogger } from '@gltf-transform/core';
+import { ProcessStats } from "../utils/index.js";
+import { Config } from '../config/index.js';
+export type PackGLTFOptions = {
+    useCache: boolean;
+    packedFiles?: Set<string>;
+    stats?: ProcessStats;
+    config: Config;
+    logger?: ILogger;
+    debug: boolean;
+    verbose?: boolean;
+};
+/** Compress a glTF file
+ */
+export declare function packGLTF(inputFile: string, outputFile: string, options: PackGLTFOptions): Promise<boolean>;

package/dist/scripts/pack-gltf.js

@@ -1,133 +1,135 @@
-import path from 'path';
-import { Logger, NodeIO, PropertyType, Verbosity } from '@gltf-transform/core';
-import { ALL_EXTENSIONS } from '@gltf-transform/extensions';
-import draco3d from 'draco3dgltf';
-import { existsSync, readFileSync, statSync, writeFileSync } from 'fs';
-import { MeshoptDecoder, MeshoptEncoder } from 'meshoptimizer';
-import { dedup, prune, resample } from '@gltf-transform/functions';
-import { ALL_EXTENSIONS as NEEDLE_EXTENSIONS, NEEDLE_compression_texture, NEEDLE_mesh_compression, } from '../extensions/index.js';
-import { isLOD, isMeshLOD, needle_animation_transform, needle_asset, needle_mesh_transform, needle_texture_transform, } from '../transforms/index.js';
-import { getOutputPath, getVersion, ioTryReadWithMissingResources, writeNodeIO } from "../utils/index.js";
-import { addToCache, getHash, tryGetFromCache, } from "../cache/index.js";
-/** Compress a glTF file
- */
-export async function packGLTF(inputFile, outputFile, options) {
-    if (!options.logger) {
-        options.logger = new Logger(Verbosity.INFO);
-    }
-    const { debug, stats, packedFiles, useCache, logger } = options;
-    if (!existsSync(inputFile)) {
-        logger.error(`WARN: can not pack, file does not exist: \"${inputFile}\"`);
-        return false;
-    }
-    // check if it's in the cache. 
-    // We only need to check mesh LOD files because image LODs are cache via our toktx transform
-    // We can not cache the main glTF files because the hash always changes for them
-    let cacheKey = undefined;
-    if (useCache && isMeshLOD(inputFile)) {
-        const existing = readFileSync(inputFile);
-        const hash = getHash(existing);
-        cacheKey = "packed-" + hash;
-        const cached = tryGetFromCache(cacheKey);
-        if (cached) {
-            logger.info(`→ Loaded compressed file from cache: \"${path.basename(inputFile)}\"`);
-            writeFileSync(inputFile, cached);
-            return true;
-        }
-    }
-    if (packedFiles) {
-        if (packedFiles.has(inputFile))
-            return true;
-        packedFiles.add(inputFile);
-    }
-    try {
-        const config = options.config;
-        if (!outputFile)
-            outputFile = inputFile;
-        else {
-            outputFile = getOutputPath(inputFile, outputFile);
-        }
-        const prevSizeInMB = statSync(inputFile).size / 1024 / 1024;
-        logger.info(`→ Compressing ${prevSizeInMB.toFixed(1)} MB: ${inputFile}`);
-        const startTime = Date.now();
-        const io = new NodeIO()
-            .registerExtensions(ALL_EXTENSIONS)
-            .registerExtensions(NEEDLE_EXTENSIONS)
-            .registerExtensions([
-            NEEDLE_compression_texture,
-            NEEDLE_mesh_compression,
-        ])
-            .registerDependencies({
-            'draco3d.decoder': await draco3d.createDecoderModule(),
-            'draco3d.encoder': await draco3d.createEncoderModule(),
-            'meshopt.decoder': MeshoptDecoder,
-            'meshopt.encoder': MeshoptEncoder,
-        });
-        const document = await ioTryReadWithMissingResources(io, inputFile); // await io.read(inputFile);
-        /** @ts-ignore */
-        document.getLogger().verbosity = options.verbose ? Verbosity.DEBUG : options.debug ? Verbosity.INFO : Verbosity.WARN;
-        let totalGPUTextureMemory = 0;
-        /** @type {Array<import('@gltf-transform/core').Transform>} */
-        const transforms = [
-            needle_asset(),
-            needle_texture_transform({
-                file: inputFile,
-                outfile: outputFile,
-                useCache,
-                noToktx: false,
-                debug: debug,
-                reportGPUMemory: val => {
-                    totalGPUTextureMemory += val;
-                },
-                config,
-            }),
-            needle_mesh_transform({ file: inputFile, config }),
-            needle_animation_transform({}),
-            resample(),
-            // Can not dedup "materials" because progressive textures will then assigned to the wrong material instance
-            // HACK: keepUniqueNames is enabled to fix https://linear.app/needle/issue/NE-6288
-            dedup({ propertyTypes: [PropertyType.MESH, PropertyType.MATERIAL] }),
-        ];
-        const isProgressiveAsset = isLOD(inputFile);
-        // TODO: progressive mesh LODs should not be pruned right now because it will remove e.g. UVs from meshes (and probably blend shapes too) (so we just not do it for any progressive asset) 
-        if (!isProgressiveAsset) {
-            transforms.push(prune({
-                // Pruning animations is not supported yet (e.g. if the animation is only referenced by a component)
-                propertyTypes: [
-                    PropertyType.MESH,
-                    PropertyType.MATERIAL,
-                    PropertyType.TEXTURE,
-                    PropertyType.ACCESSOR,
-                    PropertyType.BUFFER,
-                ],
-                keepAttributes: true,
-                keepIndices: true,
-                keepExtras: true,
-                keepSolidTextures: true,
-            }));
-        }
-        await document.transform(...transforms);
-        logger.info(`← Writing to ${outputFile}`);
-        await writeNodeIO(io, outputFile, document);
-        if (useCache && cacheKey != undefined && existsSync(outputFile))
-            addToCache(cacheKey, readFileSync(outputFile));
-        const duration = Date.now() - startTime;
-        const sizeInMB = statSync(outputFile).size / 1024 / 1024;
-        const filename = path.basename(outputFile);
-        const gpuMemoryInMB = totalGPUTextureMemory / 1024 / 1024;
-        logger.info(`← Compressing done in ${(duration / 1000).toFixed(1)} sec, ${prevSizeInMB.toFixed(1)} MB → ${sizeInMB.toFixed(1)} MB (GPU: ${gpuMemoryInMB.toFixed(1)} MB textures): ${filename} at ${outputFile}`);
-        if (stats) {
-            stats.totalFilesProcessed++;
-            stats.totalFileSizeInMB += sizeInMB;
-            stats.totalFileSizeInMBBefore += prevSizeInMB;
-            stats.totalGPUMemoryInMB += gpuMemoryInMB;
-        }
-        return true;
-    }
-    catch (err) {
-        logger.error(`Packing of "${path.basename(inputFile)}" using version ${getVersion()} failed with error:\n${err.message}`);
-        if (debug)
-            throw err;
-        return false;
-    }
-}
+import path from 'path';
+import { Logger, NodeIO, PropertyType, Verbosity } from '@gltf-transform/core';
+import { ALL_EXTENSIONS } from '@gltf-transform/extensions';
+import draco3d from 'draco3dgltf';
+import { existsSync, readFileSync, statSync, writeFileSync } from 'fs';
+import { MeshoptDecoder, MeshoptEncoder } from 'meshoptimizer';
+import { dedup, prune, resample } from '@gltf-transform/functions';
+import { ALL_EXTENSIONS as NEEDLE_EXTENSIONS, NEEDLE_compression_texture, NEEDLE_mesh_compression, } from '../extensions/index.js';
+import { isLOD, isMeshLOD, needle_animation_transform, needle_asset, needle_mesh_transform, needle_texture_transform, } from '../transforms/index.js';
+import { getOutputPath, getVersion, ioTryReadWithMissingResources, writeNodeIO } from "../utils/index.js";
+import { addToCache, getHash, tryGetFromCache, } from "../cache/index.js";
+/** Compress a glTF file
+ */
+export async function packGLTF(inputFile, outputFile, options) {
+    if (!options.logger) {
+        options.logger = new Logger(Verbosity.INFO);
+    }
+    const { debug, stats, packedFiles, useCache, logger } = options;
+    if (!existsSync(inputFile)) {
+        logger.error(`WARN: can not pack, file does not exist: \"${inputFile}\"`);
+        return false;
+    }
+    // check if it's in the cache. 
+    // We only need to check mesh LOD files because image LODs are cache via our toktx transform
+    // We can not cache the main glTF files because the hash always changes for them
+    let cacheKey = undefined;
+    if (useCache && isMeshLOD(inputFile)) {
+        const existing = readFileSync(inputFile);
+        const hash = getHash(existing);
+        cacheKey = "packed-" + hash;
+        const cached = tryGetFromCache(cacheKey);
+        if (cached) {
+            logger.info(`→ Loaded compressed file from cache: \"${path.basename(inputFile)}\"`);
+            writeFileSync(inputFile, cached);
+            return true;
+        }
+    }
+    if (packedFiles) {
+        if (packedFiles.has(inputFile))
+            return true;
+        packedFiles.add(inputFile);
+    }
+    try {
+        const config = options.config;
+        if (!outputFile)
+            outputFile = inputFile;
+        else {
+            outputFile = getOutputPath(inputFile, outputFile);
+        }
+        const prevSizeInMB = statSync(inputFile).size / 1024 / 1024;
+        logger.info(`→ Compressing ${prevSizeInMB.toFixed(1)} MB: ${inputFile}`);
+        const startTime = Date.now();
+        const io = new NodeIO()
+            .registerExtensions(ALL_EXTENSIONS)
+            .registerExtensions(NEEDLE_EXTENSIONS)
+            .registerExtensions([
+            NEEDLE_compression_texture,
+            NEEDLE_mesh_compression,
+        ])
+            .registerDependencies({
+            'draco3d.decoder': await draco3d.createDecoderModule(),
+            'draco3d.encoder': await draco3d.createEncoderModule(),
+            'meshopt.decoder': MeshoptDecoder,
+            'meshopt.encoder': MeshoptEncoder,
+        });
+        const document = await ioTryReadWithMissingResources(io, inputFile); // await io.read(inputFile);
+        /** @ts-ignore */
+        document.getLogger().verbosity = options.verbose ? Verbosity.DEBUG : options.debug ? Verbosity.INFO : Verbosity.WARN;
+        let totalGPUTextureMemory = 0;
+        /** @type {Array<import('@gltf-transform/core').Transform>} */
+        const transforms = [
+            needle_asset(),
+            needle_texture_transform({
+                file: inputFile,
+                outfile: outputFile,
+                useCache,
+                noToktx: false,
+                debug: debug,
+                reportGPUMemory: val => {
+                    totalGPUTextureMemory += val;
+                },
+                config,
+            }),
+            needle_mesh_transform({ file: inputFile, config }),
+            needle_animation_transform({}),
+            resample({
+                tolerance: 1e-6, // NOTE: lowered from 1e-4 to 1e-6 to fix https://linear.app/needle/issue/NE-6872
+            }),
+            // Can not dedup "materials" because progressive textures will then assigned to the wrong material instance
+            // HACK: keepUniqueNames is enabled to fix https://linear.app/needle/issue/NE-6288
+            dedup({ propertyTypes: [PropertyType.MESH, PropertyType.MATERIAL] }),
+        ];
+        const isProgressiveAsset = isLOD(inputFile);
+        // TODO: progressive mesh LODs should not be pruned right now because it will remove e.g. UVs from meshes (and probably blend shapes too) (so we just not do it for any progressive asset) 
+        if (!isProgressiveAsset) {
+            transforms.push(prune({
+                // Pruning animations is not supported yet (e.g. if the animation is only referenced by a component)
+                propertyTypes: [
+                    PropertyType.MESH,
+                    PropertyType.MATERIAL,
+                    PropertyType.TEXTURE,
+                    PropertyType.ACCESSOR,
+                    PropertyType.BUFFER,
+                ],
+                keepAttributes: true,
+                keepIndices: true,
+                keepExtras: true,
+                keepSolidTextures: true,
+            }));
+        }
+        await document.transform(...transforms);
+        logger.info(`← Writing to ${outputFile}`);
+        await writeNodeIO(io, outputFile, document);
+        if (useCache && cacheKey != undefined && existsSync(outputFile))
+            addToCache(cacheKey, readFileSync(outputFile));
+        const duration = Date.now() - startTime;
+        const sizeInMB = statSync(outputFile).size / 1024 / 1024;
+        const filename = path.basename(outputFile);
+        const gpuMemoryInMB = totalGPUTextureMemory / 1024 / 1024;
+        logger.info(`← Compressing done in ${(duration / 1000).toFixed(1)} sec, ${prevSizeInMB.toFixed(1)} MB → ${sizeInMB.toFixed(1)} MB (GPU: ${gpuMemoryInMB.toFixed(1)} MB textures): ${filename} at ${outputFile}`);
+        if (stats) {
+            stats.totalFilesProcessed++;
+            stats.totalFileSizeInMB += sizeInMB;
+            stats.totalFileSizeInMBBefore += prevSizeInMB;
+            stats.totalGPUMemoryInMB += gpuMemoryInMB;
+        }
+        return true;
+    }
+    catch (err) {
+        logger.error(`Packing of "${path.basename(inputFile)}" using version ${getVersion()} failed with error:\n${err.message}`);
+        if (debug)
+            throw err;
+        return false;
+    }
+}

package/dist/scripts/stats.d.ts

@@ -1,2 +1,2 @@
-import { FileStats } from "../utils/stats.js";
-export declare function calculateStats(inputfile: string): Promise<FileStats>;
+import { FileStats } from "../utils/stats.js";
+export declare function calculateStats(inputfile: string): Promise<FileStats>;

package/dist/scripts/stats.js

@@ -1,19 +1,19 @@
-import { NodeIO } from "@gltf-transform/core";
-import { ALL_EXTENSIONS } from "@gltf-transform/extensions";
-import draco3d from 'draco3dgltf';
-import { MeshoptDecoder, MeshoptEncoder } from "meshoptimizer";
-import { createNewFilestats } from "../utils/stats.js";
-export async function calculateStats(inputfile) {
-    const io = new NodeIO()
-        .registerExtensions(ALL_EXTENSIONS)
-        .registerDependencies({
-        'draco3d.decoder': await draco3d.createDecoderModule(),
-        'draco3d.encoder': await draco3d.createEncoderModule(),
-        'meshopt.decoder': MeshoptDecoder,
-        'meshopt.encoder': MeshoptEncoder,
-    });
-    const document = await io.read(inputfile);
-    const json = await io.readAsJSON(inputfile);
-    const stats = createNewFilestats(inputfile, document, json);
-    return stats;
-}
+import { NodeIO } from "@gltf-transform/core";
+import { ALL_EXTENSIONS } from "@gltf-transform/extensions";
+import draco3d from 'draco3dgltf';
+import { MeshoptDecoder, MeshoptEncoder } from "meshoptimizer";
+import { createNewFilestats } from "../utils/stats.js";
+export async function calculateStats(inputfile) {
+    const io = new NodeIO()
+        .registerExtensions(ALL_EXTENSIONS)
+        .registerDependencies({
+        'draco3d.decoder': await draco3d.createDecoderModule(),
+        'draco3d.encoder': await draco3d.createEncoderModule(),
+        'meshopt.decoder': MeshoptDecoder,
+        'meshopt.encoder': MeshoptEncoder,
+    });
+    const document = await io.read(inputfile);
+    const json = await io.readAsJSON(inputfile);
+    const stats = createNewFilestats(inputfile, document, json);
+    return stats;
+}

package/dist/transforms/index.d.ts

@@ -1,9 +1,9 @@
-export * from "./needle_asset.js";
-export * from "./toktx.js";
-export * from "./needle_toktx.js";
-export * from "./needle_progressive.js";
-export * from "./needle_webp.js";
-export * from "./needle_mesh_transform.js";
-export * from "./needle_common.js";
-export * from "./needle_texture_transform.js";
-export * from "./needle_animation_transform.js";
+export * from "./needle_asset.js";
+export * from "./toktx.js";
+export * from "./needle_toktx.js";
+export * from "./needle_progressive.js";
+export * from "./needle_webp.js";
+export * from "./needle_mesh_transform.js";
+export * from "./needle_common.js";
+export * from "./needle_texture_transform.js";
+export * from "./needle_animation_transform.js";

package/dist/transforms/index.js

@@ -1,9 +1,9 @@
-export * from "./needle_asset.js";
-export * from "./toktx.js";
-export * from "./needle_toktx.js";
-export * from "./needle_progressive.js";
-export * from "./needle_webp.js";
-export * from "./needle_mesh_transform.js";
-export * from "./needle_common.js";
-export * from "./needle_texture_transform.js";
-export * from "./needle_animation_transform.js";
+export * from "./needle_asset.js";
+export * from "./toktx.js";
+export * from "./needle_toktx.js";
+export * from "./needle_progressive.js";
+export * from "./needle_webp.js";
+export * from "./needle_mesh_transform.js";
+export * from "./needle_common.js";
+export * from "./needle_texture_transform.js";
+export * from "./needle_animation_transform.js";

package/dist/transforms/needle_animation_transform.d.ts

@@ -1,2 +1,2 @@
-import { Transform } from "@gltf-transform/core";
-export declare const needle_animation_transform: (_options: any) => Transform;
+import { Transform } from "@gltf-transform/core";
+export declare const needle_animation_transform: (_options: any) => Transform;

package/dist/transforms/needle_animation_transform.js

@@ -1,5 +1,5 @@
-export const needle_animation_transform = function (_options) {
-    // return resample();
-    return (document, _context) => {
-    };
-};
+export const needle_animation_transform = function (_options) {
+    // return resample();
+    return (document, _context) => {
+    };
+};

package/dist/transforms/needle_asset.d.ts

@@ -1,3 +1,3 @@
-import { Document, Transform } from '@gltf-transform/core';
-export declare function writeNeedleAsset(document: Document, metadata?: Record<string, object | string | number | boolean>): void;
-export declare function needle_asset(): Transform;
+import { Document, Transform } from '@gltf-transform/core';
+export declare function writeNeedleAsset(document: Document, metadata?: Record<string, object | string | number | boolean>): void;
+export declare function needle_asset(): Transform;

package/dist/transforms/needle_asset.js

@@ -1,50 +1,50 @@
-import { createTransform } from '@gltf-transform/functions';
-import { getVersion } from '../index.js';
-const generatorName = "Needle Build Pipeline";
-export function writeNeedleAsset(document, metadata) {
-    const root = document.getRoot();
-    const asset = root.getAsset();
-    if (asset) {
-        asset.extras = writeNeedleExtras(asset.extras);
-        if (metadata)
-            asset.extras = Object.assign(asset.extras, metadata);
-        const version = getVersion();
-        asset.generator = generatorName;
-        if (version?.length > 0) {
-            asset.generator += " " + version;
-        }
-    }
-}
-export function needle_asset() {
-    return createTransform("needle_asset_transform", (document) => {
-        writeNeedleAsset(document);
-    });
-}
-/** @internal */
-function writeNeedleExtras(extras) {
-    if (!extras)
-        extras = {};
-    // if the document doesnt have a needle property, add it
-    if (typeof extras === "object" && !extras.needle) {
-        let generator = generatorName;
-        const version = getVersion();
-        if (version?.length > 0)
-            generator += " " + version;
-        const time = new Date().toISOString();
-        extras.needle = {
-            generator: generator,
-            created: time,
-            updated: time,
-            revision: 0,
-        };
-    }
-    // if this is the second time this function is called, we need to update the revision number
-    else {
-        const needle_Extras = extras["needle"];
-        if (needle_Extras) {
-            needle_Extras.updated = new Date().toISOString();
-            needle_Extras.revision = needle_Extras.revision + 1;
-        }
-    }
-    return extras;
-}
+import { createTransform } from '@gltf-transform/functions';
+import { getVersion } from '../index.js';
+const generatorName = "Needle Build Pipeline";
+export function writeNeedleAsset(document, metadata) {
+    const root = document.getRoot();
+    const asset = root.getAsset();
+    if (asset) {
+        asset.extras = writeNeedleExtras(asset.extras);
+        if (metadata)
+            asset.extras = Object.assign(asset.extras, metadata);
+        const version = getVersion();
+        asset.generator = generatorName;
+        if (version?.length > 0) {
+            asset.generator += " " + version;
+        }
+    }
+}
+export function needle_asset() {
+    return createTransform("needle_asset_transform", (document) => {
+        writeNeedleAsset(document);
+    });
+}
+/** @internal */
+function writeNeedleExtras(extras) {
+    if (!extras)
+        extras = {};
+    // if the document doesnt have a needle property, add it
+    if (typeof extras === "object" && !extras.needle) {
+        let generator = generatorName;
+        const version = getVersion();
+        if (version?.length > 0)
+            generator += " " + version;
+        const time = new Date().toISOString();
+        extras.needle = {
+            generator: generator,
+            created: time,
+            updated: time,
+            revision: 0,
+        };
+    }
+    // if this is the second time this function is called, we need to update the revision number
+    else {
+        const needle_Extras = extras["needle"];
+        if (needle_Extras) {
+            needle_Extras.updated = new Date().toISOString();
+            needle_Extras.revision = needle_Extras.revision + 1;
+        }
+    }
+    return extras;
+}

package/dist/transforms/needle_common.d.ts

@@ -1,17 +1,17 @@
-import { Document, Texture } from '@gltf-transform/core';
-import { NEEDLE_compression_texture_schema } from '../extensions/index.js';
-import { Config } from '../config/index.js';
-export interface NeedleTransformContext {
-    /** full path to the file being processed */
-    file: string;
-    outfile: string;
-    config: Config;
-    debug?: boolean;
-    useCache: boolean;
-    noToktx: boolean;
-}
-export interface INeedleTextureTransformContext {
-    prepare(document: Document): Promise<void | boolean>;
-    process(index: number, texture: Texture, settings: NEEDLE_compression_texture_schema, context: NeedleTransformContext): Promise<boolean>;
-    finalize(document: Document): Promise<void>;
-}
+import { Document, Texture } from '@gltf-transform/core';
+import { NEEDLE_compression_texture_schema } from '../extensions/index.js';
+import { Config } from '../config/index.js';
+export interface NeedleTransformContext {
+    /** full path to the file being processed */
+    file: string;
+    outfile: string;
+    config: Config;
+    debug?: boolean;
+    useCache: boolean;
+    noToktx: boolean;
+}
+export interface INeedleTextureTransformContext {
+    prepare(document: Document): Promise<void | boolean>;
+    process(index: number, texture: Texture, settings: NEEDLE_compression_texture_schema, context: NeedleTransformContext): Promise<boolean>;
+    finalize(document: Document): Promise<void>;
+}

package/dist/transforms/needle_common.js

@@ -1 +1 @@
-export {};
+export {};

package/dist/transforms/needle_mesh_transform.d.ts

@@ -1,15 +1,15 @@
-import { Transform, Document, Primitive, Mesh } from "@gltf-transform/core";
-import { SimplifyOptions, WeldOptions } from "@gltf-transform/functions";
-import { NEEDLE_mesh_compression_model_root } from "../extensions/index.js";
-import { Config } from "../config/index.js";
-declare type MeshTransformContext = {
-    file: string;
-    config: Config;
-};
-/**
- * Which compression type for a model should be used. This should be respected when creating LOD meshes and the appropriate extension should be added to the LOD mesh so it receives the same mesh compression as the parent mesh
- */
-export declare function determineMeshCompression(document: Document, filePath: string): NEEDLE_mesh_compression_model_root;
-export declare const needle_mesh_transform: (context: MeshTransformContext) => Transform;
-export declare function compressPrimitive(document: Document, mesh: Mesh, prim: Primitive, index: number, weldOptions: Required<WeldOptions>, meshOptions: Required<SimplifyOptions>): Promise<Primitive>;
-export {};
+import { Transform, Document, Primitive, Mesh } from "@gltf-transform/core";
+import { SimplifyOptions, WeldOptions } from "@gltf-transform/functions";
+import { NEEDLE_mesh_compression_model_root } from "../extensions/index.js";
+import { Config } from "../config/index.js";
+declare type MeshTransformContext = {
+    file: string;
+    config: Config;
+};
+/**
+ * Which compression type for a model should be used. This should be respected when creating LOD meshes and the appropriate extension should be added to the LOD mesh so it receives the same mesh compression as the parent mesh
+ */
+export declare function determineMeshCompression(document: Document, filePath: string): NEEDLE_mesh_compression_model_root;
+export declare const needle_mesh_transform: (context: MeshTransformContext) => Transform;
+export declare function compressPrimitive(document: Document, mesh: Mesh, prim: Primitive, index: number, weldOptions: Required<WeldOptions>, meshOptions: Required<SimplifyOptions>): Promise<Primitive>;
+export {};