@needle-tools/gltf-build-pipeline 2.16.0-next.2b9edfd → 2.16.0-next.8ceb45e

package/README.md

@@ -49,7 +49,7 @@ The `gltf` value may also be a string shorthand for `usecase` — `"gltf": "prod
 | `usecase` | `"default" \| "product" \| "world"` | `"default"` | High-level optimisation profile. |
 | `textures.lods` | `boolean` | `true` | Generate progressive texture LODs. |
 | `meshes.lods` | `boolean` | `true` | Generate progressive mesh LODs. |
-| `audio.enabled` | `boolean` | `true` | Compress externally referenced audio files (`.wav` / `.mp3` / `.ogg` / `.flac` / `.m4a` / `.aac`) to Opus in an `.ogg` container, rewriting the URIs in the glTF. Requires `ffmpeg` with `libopus` on `PATH`; when missing the build logs a warning and leaves the audio files untouched. |
+| `audio.enabled` | `boolean` | `true` | Compress externally referenced `.wav` audio files to Opus in an `.ogg` container, rewriting the URIs in the glTF. Lossy formats (`.mp3`, `.ogg`, `.m4a`, `.aac`) pass through unchanged to avoid compounding compression artifacts. Requires `ffmpeg` with `libopus` on `PATH`; when missing the build logs a warning and leaves the audio files untouched. |
 | `audio.bitrate` | `number` (kbps) | `128` | Opus encoding bitrate. 96 is near-transparent for most music; 128 matches YouTube's music tier and is the safe "won't sound bad" default. Drop to 48–64 for known mono/UI-only assets. |
 | `exr.enabled` | `boolean` | `true` | Convert EXR textures to KTX2 HDR via PMREM. When `false`, EXR textures (bundled and externally referenced) are left as-is so a downstream step can handle them. |
 

package/dist/cli/index.js

@@ -7,9 +7,10 @@ import { UsecaseOptions, createConfig, getConfig } from '../config/index.js';
 import { isLOD, make_progressive } from '../transforms/needle_progressive.js';
 import { cacheSizeLimit, clearCache, ensureHashReady, limitCacheSize } from '../cache/cache.js';
 import { computeJobKey, saveJobResult, tryRestoreJobResult } from '../cache/job-cache.js';
-import { existsSync, statSync } from 'fs';
+import { convertExrBytesToPmremKtx2, createPmremRuntime, disposePmremRuntime } from '../transforms/needle_pmrem.js';
+import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from 'fs';
 import { ensureIsDirectory, foreachGLTF, isDirectory } from '../utils/fileutils.js';
-import path, { dirname, resolve } from 'path';
+import path, { basename, dirname, resolve } from 'path';
 import { ERROR_CODES } from '../constants.js';
 import { trackPipelineStart, trackPipelineEnd, trackError } from '../utils/analytics.js';
 // For testing / dev you can run `npm link` in the package directory
@@ -268,7 +269,112 @@ Each version will be compressed and written to the output directory.
     });
     if (useCache)
         limitCacheSize();
+})
+    .command("pmrem", "Convert EXR files to PMREM-processed KTX2 HDR (Needle PMREM)")
+    .help(`Runs the PMREM WASM + basisu encoder on .exr files, producing <name>.pmrem.ktx2.
+This is the same processing the Needle build pipeline applies to EXR textures inside
+GLB/GLTF files, exposed as a standalone command for raw .exr inputs.
+`)
+    .argument('<input>', "Path to an .exr file OR a directory containing .exr files (recursive)", { validator: program.STRING })
+    .argument('<output>', "Output file (when input is a single .exr) or output directory. Defaults to writing next to the input file.", { default: null, validator: program.STRING })
+    .option("--cache", "Use \"--cache False\" to disable caching.", { validator: program.BOOLEAN, default: true })
+    .option("--debug", "Enable verbose output with \"--debug True\"", { validator: program.BOOLEAN, default: false })
+    .option("--verbose", "Enable verbose output with \"--verbose True\"", { validator: program.BOOLEAN, default: false })
+    .hide()
+    .action(async ({ logger, args, options }) => {
+    logger.level = (options.debug || options.verbose) ? "debug" : "info";
+    await ensureHashReady();
+    const input = args.input.toString();
+    if (!existsSync(input)) {
+        logger.error(`Input does not exist: ${input}`);
+        process.exit(ERROR_CODES.INVALID_ARGS);
+    }
+    const exrFiles = [];
+    const inputIsDirectory = isDirectory(input);
+    if (inputIsDirectory) {
+        collectExrFiles(input, exrFiles);
+    }
+    else if (input.toLowerCase().endsWith('.exr')) {
+        exrFiles.push(input);
+    }
+    else {
+        logger.error(`Input is not an .exr file or directory: ${input}`);
+        process.exit(ERROR_CODES.INVALID_ARGS);
+    }
+    if (exrFiles.length === 0) {
+        logger.warn(`No .exr files found in ${input}`);
+        return;
+    }
+    // caporal's program.cast(false) forces String(null) → "null" for the
+    // missing positional default, so treat that literal as "no output given".
+    const rawOutput = args.output?.toString() || null;
+    let outputArg = (rawOutput && rawOutput !== 'null') ? rawOutput : null;
+    if (outputArg && !path.isAbsolute(outputArg)) {
+        const base = inputIsDirectory ? input : dirname(input);
+        outputArg = resolve(base, outputArg);
+    }
+    const useCache = options.cache !== false;
+    logger.info(`[Needle Build Pipeline] v${getVersion()} — pmrem: ${exrFiles.length} file(s)`);
+    const runtime = await createPmremRuntime(logger);
+    if (!runtime) {
+        logger.error('pmrem runtime is not available (WASM or basisu binary missing). Run `npm run build:pmrem` in the package directory.');
+        process.exit(ERROR_CODES.PACKING_FAILED);
+    }
+    try {
+        for (const exrPath of exrFiles) {
+            const outPath = resolvePmremOutputPath(exrPath, input, inputIsDirectory, outputArg);
+            logger.info(`→ pmrem ${exrPath} → ${outPath}`);
+            const exrBytes = readFileSync(exrPath);
+            const ktx2Bytes = await convertExrBytesToPmremKtx2(runtime, new Uint8Array(exrBytes.buffer, exrBytes.byteOffset, exrBytes.byteLength), { useCache, logLabel: `pmrem ${basename(exrPath)}` });
+            writeFileSync(outPath, ktx2Bytes);
+        }
+    }
+    finally {
+        await disposePmremRuntime(runtime);
+    }
+    if (useCache)
+        limitCacheSize();
 });
+function collectExrFiles(dir, out) {
+    for (const entry of readdirSync(dir)) {
+        if (entry === 'node_modules' || entry.startsWith('.'))
+            continue;
+        const full = path.join(dir, entry);
+        const st = statSync(full);
+        if (st.isDirectory()) {
+            collectExrFiles(full, out);
+        }
+        else if (entry.toLowerCase().endsWith('.exr')) {
+            out.push(full);
+        }
+    }
+}
+function resolvePmremOutputPath(exrPath, input, inputIsDirectory, outputArg) {
+    const outName = basename(exrPath).replace(/\.exr$/i, '.pmrem.ktx2');
+    if (!outputArg) {
+        // Default: write next to the input file
+        return path.join(dirname(exrPath), outName);
+    }
+    if (inputIsDirectory) {
+        // Mirror the directory layout under outputArg, treating it as a directory
+        const rel = path.relative(input, exrPath);
+        const relDir = dirname(rel);
+        const outDir = relDir === '.' ? outputArg : path.join(outputArg, relDir);
+        ensureIsDirectory(outDir);
+        return path.join(outDir, outName);
+    }
+    // Single-file input. outputArg may be an existing directory, or an explicit file path.
+    if (existsSync(outputArg) && isDirectory(outputArg)) {
+        return path.join(outputArg, outName);
+    }
+    if (outputArg.toLowerCase().endsWith('.ktx2')) {
+        ensureIsDirectory(dirname(outputArg));
+        return outputArg;
+    }
+    // Treat as a directory that does not exist yet
+    ensureIsDirectory(outputArg);
+    return path.join(outputArg, outName);
+}
 program.run().catch(err => {
     // Since we still invoke this package with paths when running npm scripts we need to ignore this error
     // We might want to move this code here into an extra package.

package/dist/transforms/needle_audio_registry.d.ts

@@ -28,8 +28,10 @@ export type AudioRef = {
 export declare function registerAudioRef(ref: AudioRef): void;
 export declare function listAudioRefs(): AudioRef[];
 export declare function clearAudioRegistry(): void;
-/** Audio extensions we recognise. Comparison is case-insensitive. */
-export declare const AUDIO_EXTENSIONS: readonly [".wav", ".mp3", ".ogg", ".flac", ".m4a", ".aac"];
+/** Audio extensions the compression transform will re-encode. Lossless only —
+ *  re-encoding lossy formats (mp3/m4a/aac/ogg) would compound artifacts. Those
+ *  paths are still valid in source glTFs; they are simply passed through. */
+export declare const AUDIO_EXTENSIONS: readonly [".wav"];
 export declare function isAudioUri(value: string): boolean;
 /** Returns true if the URI is a relative path we should attempt to resolve+compress.
  *  Absolute URLs (http(s), data, file, blob, leading slash, drive letter) are passed through unchanged. */

package/dist/transforms/needle_audio_registry.js

@@ -22,8 +22,10 @@ export function listAudioRefs() {
 export function clearAudioRegistry() {
     _refs = [];
 }
-/** Audio extensions we recognise. Comparison is case-insensitive. */
-export const AUDIO_EXTENSIONS = ['.wav', '.mp3', '.ogg', '.flac', '.m4a', '.aac'];
+/** Audio extensions the compression transform will re-encode. Lossless only —
+ *  re-encoding lossy formats (mp3/m4a/aac/ogg) would compound artifacts. Those
+ *  paths are still valid in source glTFs; they are simply passed through. */
+export const AUDIO_EXTENSIONS = ['.wav'];
 const _audioRegex = new RegExp(`(${AUDIO_EXTENSIONS.map(e => '\\' + e).join('|')})$`, 'i');
 export function isAudioUri(value) {
     return _audioRegex.test(value);

package/dist/transforms/needle_pmrem.d.ts

@@ -1,13 +1,34 @@
-import { Document, Texture } from '@gltf-transform/core';
+import { Document, ILogger, Texture } from '@gltf-transform/core';
 import { NEEDLE_compression_texture_schema } from '../extensions/index.js';
 import { INeedleTextureTransformContext, NeedleTransformContext } from './needle_common.js';
+export interface PmremRuntime {
+    wasmModule: any;
+    basisuExe: string;
+    pmremDir: string;
+    tmpDir: string;
+    logger: ILogger;
+}
+/**
+ * Load the PMREM WASM module and locate the basisu binary, returning a runtime that
+ * can be passed to {@link convertExrBytesToPmremKtx2}. Returns null if WASM or basisu
+ * is missing — callers can decide whether that is fatal.
+ *
+ * Each runtime owns a per-instance temp directory; call {@link disposePmremRuntime}
+ * to clean up.
+ */
+export declare function createPmremRuntime(logger: ILogger): Promise<PmremRuntime | null>;
+export declare function disposePmremRuntime(runtime: PmremRuntime | null): Promise<void>;
+/**
+ * Convert raw .exr bytes to KTX2 HDR bytes using PMREM + basisu.
+ * Result is cached on disk keyed by the EXR content hash when `useCache` is true.
+ */
+export declare function convertExrBytesToPmremKtx2(runtime: PmremRuntime, exrBytes: Uint8Array, opts?: {
+    useCache?: boolean;
+    logLabel?: string;
+}): Promise<Uint8Array>;
 export declare class NeedlePmremContext implements INeedleTextureTransformContext {
-    private wasmModule;
-    private pmremDir;
-    private basisuExe;
-    private tmpDir;
+    private runtime;
     private processed;
-    private available;
     private logger;
     private readonly convertedTextures;
     /** In-memory dedup: keyed by EXR content hash, resolves to KTX2 bytes */
@@ -16,6 +37,5 @@ export declare class NeedlePmremContext implements INeedleTextureTransformContex
     process(index: number, texture: Texture, _settings: NEEDLE_compression_texture_schema | null, context: NeedleTransformContext): Promise<boolean>;
     /** Get or process EXR bytes into KTX2, with in-memory dedup and disk caching */
     private getOrProcessExr;
-    private processExrToKtx2;
     finalize(document: Document): Promise<void>;
 }

package/dist/transforms/needle_pmrem.js

@@ -9,6 +9,100 @@ import { createHash } from 'crypto';
 import tmp from 'tmp';
 import { addToCache, tryGetFromCache } from '../cache/index.js';
 import { testAssert } from '../utils/test-assert.js';
+/**
+ * Load the PMREM WASM module and locate the basisu binary, returning a runtime that
+ * can be passed to {@link convertExrBytesToPmremKtx2}. Returns null if WASM or basisu
+ * is missing — callers can decide whether that is fatal.
+ *
+ * Each runtime owns a per-instance temp directory; call {@link disposePmremRuntime}
+ * to clean up.
+ */
+export async function createPmremRuntime(logger) {
+    const pmremDir = getPmremDir();
+    const wasmJsPath = join(pmremDir, 'pkg', 'pmrem_wasm.js');
+    const wasmBinPath = join(pmremDir, 'pkg', 'pmrem_wasm_bg.wasm');
+    if (!existsSync(wasmJsPath) || !existsSync(wasmBinPath)) {
+        logger.warn('pmrem: WASM not found — EXR textures will not be processed');
+        testAssert(false, 'pmrem WASM files are missing. Please run `npm run build:pmrem` to build the tools/pmrem/ WASM module.');
+        return null;
+    }
+    const basisuExe = resolveBasisuExe(pmremDir);
+    if (!existsSync(basisuExe)) {
+        logger.warn(`pmrem: basisu binary not found at ${basisuExe} — EXR textures will not be processed`);
+        testAssert(false, `basisu executable is missing for platform ${process.platform}. Please run \`npm run build:pmrem\` to build the tools/pmrem/ binaries.`);
+        return null;
+    }
+    if (process.platform !== 'win32') {
+        try {
+            chmodSync(basisuExe, 0o755);
+        }
+        catch { /* ignore */ }
+    }
+    let wasmModule;
+    try {
+        const mod = await import(pathToFileURL(wasmJsPath).href);
+        const wasmBytes = readFileSync(wasmBinPath);
+        await mod.default({ module_or_path: wasmBytes });
+        wasmModule = mod;
+    }
+    catch (err) {
+        logger.warn(`pmrem: Failed to load WASM — ${err.message}`);
+        testAssert(false, `Failed to load pmrem WASM module: ${err.message}`);
+        return null;
+    }
+    const tmpDir = join(tmp.tmpdir, 'needle-pmrem', uuid());
+    mkdirSync(tmpDir, { recursive: true });
+    logger.debug('pmrem: Ready (WASM + basisu loaded)');
+    return { wasmModule, basisuExe, pmremDir, tmpDir, logger };
+}
+export async function disposePmremRuntime(runtime) {
+    if (runtime?.tmpDir) {
+        await safeRmDir(runtime.tmpDir);
+    }
+}
+/**
+ * Convert raw .exr bytes to KTX2 HDR bytes using PMREM + basisu.
+ * Result is cached on disk keyed by the EXR content hash when `useCache` is true.
+ */
+export async function convertExrBytesToPmremKtx2(runtime, exrBytes, opts = {}) {
+    const useCache = opts.useCache !== false;
+    const label = opts.logLabel ?? 'pmrem';
+    const logger = runtime.logger;
+    const contentHash = createHash('md5').update(exrBytes).digest('hex');
+    const cacheKey = `pmrem-${contentHash}`;
+    if (useCache) {
+        const cached = tryGetFromCache(cacheKey);
+        if (cached && cached.length > 0) {
+            logger.debug(`${label}: loaded from cache`);
+            return cached;
+        }
+    }
+    const inputSize = exrBytes.byteLength < 100 * 1024
+        ? `${(exrBytes.byteLength / 1024).toFixed(0)} KB`
+        : `${(exrBytes.byteLength / (1024 * 1024)).toFixed(2)} MB`;
+    logger.debug(`${label}: Running PMREM WASM (${inputSize} EXR) — this may take a while...`);
+    await new Promise(r => setTimeout(r, 0));
+    const t0 = Date.now();
+    const pmremExrBytes = runtime.wasmModule.pmrem_exr(exrBytes);
+    const elapsed = ((Date.now() - t0) / 1000).toFixed(1);
+    logger.debug(`${label}: PMREM done in ${elapsed}s (${(pmremExrBytes.byteLength / 1024 / 1024).toFixed(1)} MB)`);
+    const id = uuid();
+    const tempExr = join(runtime.tmpDir, `${id}.pmrem.exr`);
+    const tempKtx2 = join(runtime.tmpDir, `${id}.ktx2`);
+    writeFileSync(tempExr, Buffer.from(pmremExrBytes));
+    logger.debug(`${label}: Encoding KTX2 HDR...`);
+    // 6x6 needs an update in Needle before we can enable it
+    const variant = 'hdr4x4';
+    await encodeKTX2WithBasisu(runtime.basisuExe, tempExr, tempKtx2, variant, true);
+    if (!existsSync(tempKtx2)) {
+        throw new Error(`${label}: basisu did not produce output`);
+    }
+    const ktx2Bytes = readFileSync(tempKtx2);
+    if (useCache) {
+        addToCache(cacheKey, ktx2Bytes);
+    }
+    return new Uint8Array(ktx2Bytes);
+}
 /** Resolve the tools/pmrem/ directory relative to this file.
  *  At runtime this file is at dist/transforms/needle_pmrem.js,
  *  so tools/pmrem/ is at ../../tools/pmrem/ */
@@ -43,12 +137,8 @@ function encodeKTX2WithBasisu(basisuExe, exrPath, outPath, variant, mipmaps) {
     });
 }
 export class NeedlePmremContext {
-    wasmModule = null;
-    pmremDir = '';
-    basisuExe = '';
-    tmpDir = '';
+    runtime = null;
     processed = 0;
-    available = false;
     logger;
     convertedTextures = [];
     /** In-memory dedup: keyed by EXR content hash, resolves to KTX2 bytes */
@@ -56,50 +146,11 @@ export class NeedlePmremContext {
     async prepare(document) {
         this.logger = document.getLogger();
         this.processed = 0;
-        this.pmremDir = getPmremDir();
-        // Check WASM exists
-        const wasmJsPath = join(this.pmremDir, 'pkg', 'pmrem_wasm.js');
-        const wasmBinPath = join(this.pmremDir, 'pkg', 'pmrem_wasm_bg.wasm');
-        if (!existsSync(wasmJsPath) || !existsSync(wasmBinPath)) {
-            this.logger.warn('pmrem: WASM not found — EXR textures will not be processed');
-            testAssert(false, 'pmrem WASM files are missing. Please run `npm run build:pmrem` to build the tools/pmrem/ WASM module.');
-            return false;
-        }
-        // Check basisu binary
-        this.basisuExe = resolveBasisuExe(this.pmremDir);
-        if (!existsSync(this.basisuExe)) {
-            this.logger.warn(`pmrem: basisu binary not found at ${this.basisuExe} — EXR textures will not be processed`);
-            testAssert(false, `basisu executable is missing for platform ${process.platform}. Please run \`npm run build:pmrem\` to build the tools/pmrem/ binaries.`);
-            return false;
-        }
-        // Set executable permission
-        if (process.platform !== 'win32') {
-            try {
-                chmodSync(this.basisuExe, 0o755);
-            }
-            catch { /* ignore */ }
-        }
-        // Load WASM
-        try {
-            const mod = await import(pathToFileURL(wasmJsPath).href);
-            const wasmBytes = readFileSync(wasmBinPath);
-            await mod.default({ module_or_path: wasmBytes });
-            this.wasmModule = mod;
-        }
-        catch (err) {
-            this.logger.warn(`pmrem: Failed to load WASM — ${err.message}`);
-            testAssert(false, `Failed to load pmrem WASM module: ${err.message}`);
-            return false;
-        }
-        // Create temp directory (per-instance to avoid parallel cleanup races)
-        this.tmpDir = join(tmp.tmpdir, 'needle-pmrem', uuid());
-        mkdirSync(this.tmpDir, { recursive: true });
-        this.available = true;
-        this.logger.debug('pmrem: Ready (WASM + basisu loaded)');
-        return true;
+        this.runtime = await createPmremRuntime(this.logger);
+        return this.runtime !== null;
     }
     async process(index, texture, _settings, context) {
-        if (!this.available)
+        if (!this.runtime)
             return false;
         if (texture.getMimeType() !== 'image/exr')
             return false;
@@ -163,64 +214,24 @@ export class NeedlePmremContext {
     }
     /** Get or process EXR bytes into KTX2, with in-memory dedup and disk caching */
     getOrProcessExr(cacheKey, exrBytes, index, name, useCache) {
-        // In-memory dedup: if we're already processing identical EXR content, reuse the promise
         const existing = this.processingPromises.get(cacheKey);
         if (existing) {
             this.logger.debug(`NEEDLE_pmrem[${index}] ${name}: reusing in-flight result (identical content)`);
             return existing;
         }
-        const promise = this.processExrToKtx2(cacheKey, exrBytes, index, name, useCache);
+        const promise = convertExrBytesToPmremKtx2(this.runtime, exrBytes, {
+            useCache,
+            logLabel: `NEEDLE_pmrem[${index}] ${name}`,
+        });
         this.processingPromises.set(cacheKey, promise);
         return promise;
     }
-    async processExrToKtx2(cacheKey, exrBytes, index, name, useCache) {
-        // Disk cache check
-        if (useCache) {
-            const cached = tryGetFromCache(cacheKey);
-            if (cached && cached.length > 0) {
-                this.logger.debug(`NEEDLE_pmrem[${index}] ${name}: loaded from cache`);
-                return cached;
-            }
-        }
-        // 1. Run PMREM on the EXR bytes (synchronous WASM — may take a while)
-        const inputSize = exrBytes.byteLength < 100 * 1024
-            ? `${(exrBytes.byteLength / 1024).toFixed(0)} KB`
-            : `${(exrBytes.byteLength / (1024 * 1024)).toFixed(2)} MB`;
-        this.logger.debug(`NEEDLE_pmrem[${index}] ${name}: Running PMREM WASM (${inputSize} EXR) — this may take a while...`);
-        // Yield to allow log to flush before blocking WASM call
-        await new Promise(r => setTimeout(r, 0));
-        const t0 = Date.now();
-        const pmremExrBytes = this.wasmModule.pmrem_exr(exrBytes);
-        const elapsed = ((Date.now() - t0) / 1000).toFixed(1);
-        this.logger.debug(`NEEDLE_pmrem[${index}] ${name}: PMREM done in ${elapsed}s (${(pmremExrBytes.byteLength / 1024 / 1024).toFixed(1)} MB)`);
-        // 2. Write PMREM EXR to temp file
-        const id = uuid();
-        const tempExr = join(this.tmpDir, `${id}.pmrem.exr`);
-        const tempKtx2 = join(this.tmpDir, `${id}.ktx2`);
-        writeFileSync(tempExr, Buffer.from(pmremExrBytes));
-        // 3. Encode to KTX2 HDR via basisu
-        this.logger.debug(`NEEDLE_pmrem[${index}] ${name}: Encoding KTX2 HDR...`);
-        const variant = 'hdr4x4'; // 6x6 needs an update in Needle
-        await encodeKTX2WithBasisu(this.basisuExe, tempExr, tempKtx2, variant, true);
-        if (!existsSync(tempKtx2)) {
-            throw new Error(`NEEDLE_pmrem[${index}] ${name}: basisu did not produce output`);
-        }
-        // 4. Read KTX2 result
-        const ktx2Bytes = readFileSync(tempKtx2);
-        // Store in disk cache
-        if (useCache) {
-            addToCache(cacheKey, ktx2Bytes);
-        }
-        return new Uint8Array(ktx2Bytes);
-    }
     async finalize(document) {
         if (this.processed > 0) {
-            // Register NEEDLE_pmrem extension and mark converted textures
             const pmremExt = document.createExtension(NEEDLE_pmrem);
             for (const tex of this.convertedTextures) {
                 pmremExt.addTexture(tex);
             }
-            // If no textures use EXR anymore, remove the EXT_texture_exr extension from the document
             const hasExr = document.getRoot().listTextures().some(t => t.getMimeType() === 'image/exr');
             if (!hasExr) {
                 const exrExt = document.getRoot().listExtensionsUsed()
@@ -230,9 +241,7 @@ export class NeedlePmremContext {
                 }
             }
         }
-        // Clean up temp directory
-        if (this.tmpDir) {
-            await safeRmDir(this.tmpDir);
-        }
+        await disposePmremRuntime(this.runtime);
+        this.runtime = null;
     }
 }

package/dist/utils/version.gen.d.ts

@@ -1 +1 @@
-export declare const version = "2.16.0-next.2b9edfd";
+export declare const version = "2.16.0-next.8ceb45e";

package/dist/utils/version.gen.js

@@ -1 +1 @@
-export const version = "2.16.0-next.2b9edfd";
+export const version = "2.16.0-next.8ceb45e";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@needle-tools/gltf-build-pipeline",
-  "version": "2.16.0-next.2b9edfd",
+  "version": "2.16.0-next.8ceb45e",
   "description": "Pipeline and tools for optimizing gltf files using gltf-transform and compression settings within glTF extensions",
   "main": "dist/index.js",
   "type": "module",