usd-gltf 0.3.0 → 0.3.1

package/README.md

@@ -52,6 +52,21 @@ import draco3d from 'draco3d';
 const usdz = await glbToUSD( glb, { dracoDecoder: await draco3d.createDecoderModule() } );
 ```
 
+The extension requires accessors to describe the decoded data exactly. When they don't, conversion rejects with a `DracoMismatchError`. Its `kind` says what disagrees: `'count'`, `'index-count'`, `'components'`, `'component-type'`, `'attribute'` or `'shared-accessor'`. Its `mesh`, `primitive`, `semantic`, `accessor`, `declared` and `decoded` fields say where and by how much.
+
+Some files declare stale counts, for example from metadata written before compression changed the vertex layout. `recoverDracoCounts: true` converts those using the decoded counts and reports each one through `log`. It only does so when everything else that depends on those counts can be checked against the decoded data:
+
+- the accessors are used only by Draco primitives decoding the same data;
+- the primitive's uncompressed attributes and morph targets have the decoded vertex count;
+- the accessors aren't sparse;
+- the decoded positions match `POSITION`'s `min` and `max`.
+
+Otherwise it still rejects, with `unrecoverable` saying why. Other mismatches, such as a different number of components, are never recovered. The decoder's output is sized by the decoded data, never by the declared counts, and counts against the limits below either way.
+
+```js
+const usdz = await glbToUSD( glb, { recoverDracoCounts: true, log: console.warn } );
+```
+
 ## Limits
 
 Input size alone doesn't bound how much memory a conversion needs: an accessor can declare millions of vertices with no data behind them, and compressed geometry and images expand when decoded. Both directions take opt-in limits:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "usd-gltf",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Convert between USD (usda, usdc, usdz) and glTF / GLB, pure JavaScript with no dependencies",
   "type": "module",
   "main": "src/index.js",

package/src/gltf/document.js

@@ -2,7 +2,7 @@
 
 import { readGLB, writeGLB } from './glb.js';
 import { decodeMeshoptView } from './meshopt.js';
-import { decodeDracoPrimitive, loadDracoDecoder, needsDraco } from './draco.js';
+import { decodeDracoPrimitive, loadDracoDecoder, needsDraco, resolveDracoAccessors } from './draco.js';
 import { Budget, checkSize } from '../limits.js';
 
 const COMPONENT_ARRAYS = {
@@ -215,9 +215,11 @@ export class GLTFDocument {
 /**
  * Loads a glTF or GLB.
  * @param {Uint8Array} bytes
- * @param {{ resolver?: ( uri: string ) => Promise<Uint8Array>|Uint8Array, dracoDecoder?: object|Promise<object> }} [options] resolver loads external uris (already decoded from URI escaping); dracoDecoder is a Draco decoder module, loaded when needed if not given
+ * @param {{ resolver?: ( uri: string ) => Promise<Uint8Array>|Uint8Array, dracoDecoder?: object|Promise<object>, recoverDracoCounts?: boolean, log?: ( message: string ) => void }} [options]
+ *   resolver loads external uris (already decoded from URI escaping); dracoDecoder is a Draco decoder module, loaded when needed if not given;
+ *   recoverDracoCounts uses decoded Draco counts that disagree with their accessors when that can be checked, and logs it
  */
-export async function readGLTF( bytes, { resolver = null, budget = new Budget(), dracoDecoder = null } = {} ) {
+export async function readGLTF( bytes, { resolver = null, budget = new Budget(), dracoDecoder = null, recoverDracoCounts = false, log = () => {} } = {} ) {
 
 	let json, bin = null;
 	bytes = plainBytes( bytes );
@@ -268,19 +270,19 @@ export async function readGLTF( bytes, { resolver = null, budget = new Budget(),
 	} );
 
 	// Draco primitives without uncompressed fallback data
-	const draco = ( json.meshes || [] ).flatMap( ( mesh ) => mesh.primitives ).filter( ( p ) => needsDraco( json, p ) );
+	const draco = ( json.meshes || [] ).flatMap( ( mesh, m ) => ( mesh.primitives || [] ).map( ( primitive, index ) => ( { mesh: m, index, primitive } ) ) ).filter( ( p ) => needsDraco( json, p.primitive ) );
 
 	if ( draco.length ) {
 
 		const decoder = await ( dracoDecoder || loadDracoDecoder() );
-
-		for ( const primitive of draco ) {
+		const decoded = draco.map( ( where ) => {
 
 			budget.check();
-			const bytes = doc.bufferViewBytes( primitive.extensions.KHR_draco_mesh_compression.bufferView );
-			for ( const [ index, data ] of decodeDracoPrimitive( decoder, bytes, json, primitive, budget ) ) doc.decodedAccessors.set( index, data );
+			const bytes = doc.bufferViewBytes( where.primitive.extensions.KHR_draco_mesh_compression.bufferView );
+			return { ...where, ...decodeDracoPrimitive( decoder, bytes, json, where, budget ) };
 
-		}
+		} );
+		doc.decodedAccessors = resolveDracoAccessors( json, decoded, { recoverCounts: recoverDracoCounts, log } );
 
 	}
 

package/src/gltf/draco.js

@@ -12,6 +12,8 @@ const CDN_FILES = {
 
 const DATA_TYPES = { 5120: 'DT_INT8', 5121: 'DT_UINT8', 5122: 'DT_INT16', 5123: 'DT_UINT16', 5125: 'DT_UINT32', 5126: 'DT_FLOAT32' };
 const COMPONENT_ARRAYS = { 5120: Int8Array, 5121: Uint8Array, 5122: Int16Array, 5123: Uint16Array, 5125: Uint32Array, 5126: Float32Array };
+const INDEX_ARRAYS = { 5121: Uint8Array, 5123: Uint16Array, 5125: Uint32Array };
+const INDEX_MAX = { 5121: 0xFF, 5123: 0xFFFF, 5125: 0xFFFFFFFF };
 const TYPE_SIZES = { SCALAR: 1, VEC2: 2, VEC3: 3, VEC4: 4, MAT2: 4, MAT3: 9, MAT4: 16 };
 
 let defaultDecoder = null;
@@ -93,21 +95,65 @@ export function needsDraco( json, primitive ) {
 }
 
 /**
- * Decodes one Draco compressed primitive into the data of the accessors it describes.
+ * Thrown when decoded Draco data doesn't match the accessors describing it, which the extension
+ * requires. kind says what disagrees:
+ * - 'count': an attribute decodes to a different number of elements than its accessor's count
+ * - 'index-count': the decoded triangles need a different number of indices than declared
+ * - 'components': an attribute decodes to a different number of components than its type has
+ * - 'component-type': the accessor's componentType can't hold the decoded values
+ * - 'attribute': the Draco data has no attribute with the extension's id
+ * - 'shared-accessor': one accessor is decoded more than once, to different data
+ * With recoverDracoCounts, count mismatches that can be checked are recovered instead; when one
+ * can't be, unrecoverable says why.
+ */
+export class DracoMismatchError extends Error {
+
+	constructor( { kind, mesh, primitive, semantic, accessor, declared, decoded, unrecoverable = null } ) {
+
+		const what = {
+			'count': () => `${ semantic } decodes to ${ decoded } elements, but accessor ${ accessor } declares ${ declared }`,
+			'index-count': () => `the triangles decode to ${ decoded } indices, but accessor ${ accessor } declares ${ declared }`,
+			'components': () => `${ semantic } decodes to ${ decoded } components, but accessor ${ accessor } is ${ declared }`,
+			'component-type': () => `${ semantic } decodes to values accessor ${ accessor } can't hold as componentType ${ declared }`,
+			'attribute': () => `there is no ${ semantic } attribute with id ${ declared }`,
+			'shared-accessor': () => `accessor ${ accessor } (${ semantic }) is decoded more than once, to different data`,
+		}[ kind ]();
+		const counts = kind === 'count' || kind === 'index-count';
+		const hint = unrecoverable ? `; not recovered, as ${ unrecoverable }` : counts ? '; the recoverDracoCounts option can use the decoded count' : '';
+		super( `usd-gltf: Draco mesh ${ mesh } primitive ${ primitive }: ${ what }${ hint }` );
+		this.name = 'DracoMismatchError';
+		this.code = 'USD_GLTF_DRACO_MISMATCH';
+		Object.assign( this, { kind, mesh, primitive, semantic, accessor, declared, decoded, unrecoverable } );
+
+	}
+
+}
+
+/**
+ * Decodes one Draco compressed primitive. Allocations are sized by the decoded data, never by
+ * the declared accessor counts, which resolveDracoAccessors checks afterwards.
  * @param {object} draco decoder module
  * @param {Uint8Array} bytes the extension's bufferView
  * @param {object} json
- * @param {object} primitive
+ * @param {{ mesh: number, index: number, primitive: object }} where the primitive and its place in the document
  * @param {import('../limits.js').Budget} budget
- * @returns {Map<number, ArrayLike<number>>} accessor index -> data, in the accessor's component type
+ * @returns {{ points: number, indexCount: number|null, data: Map<number, ArrayLike<number>> }} data is accessor index -> values, in the accessor's component type
  */
-export function decodeDracoPrimitive( draco, bytes, json, primitive, budget ) {
+export function decodeDracoPrimitive( draco, bytes, json, { mesh, index: primitiveIndex, primitive }, budget ) {
 
 	const ext = primitive.extensions.KHR_draco_mesh_compression;
 	const decoder = new draco.Decoder();
 	const array = new Int8Array( bytes.buffer, bytes.byteOffset, bytes.byteLength );
-	const out = new Map();
-	let geometry = null;
+	const mismatch = ( info ) => new DracoMismatchError( { mesh, primitive: primitiveIndex, ...info } );
+	const data = new Map();
+	let geometry = null, points = 0, indexCount = null;
+
+	const put = ( semantic, accessor, values ) => {
+
+		if ( data.has( accessor ) && ! sameValues( data.get( accessor ), values ) ) throw mismatch( { kind: 'shared-accessor', semantic, accessor } );
+		data.set( accessor, values );
+
+	};
 
 	try {
 
@@ -132,30 +178,36 @@ export function decodeDracoPrimitive( draco, bytes, json, primitive, budget ) {
 
 		if ( ! status.ok() || geometry.ptr === 0 ) throw new Error( `usd-gltf: Draco decoding failed: ${ status.error_msg() }` );
 
-		const points = geometry.num_points();
+		points = geometry.num_points();
 
-		for ( const [ name, id ] of Object.entries( ext.attributes ) ) {
+		for ( const [ semantic, id ] of Object.entries( ext.attributes ) ) {
 
-			const index = primitive.attributes[ name ];
+			const index = primitive.attributes[ semantic ];
 			const accessor = json.accessors[ index ];
 			if ( accessor === undefined ) continue;
 			const ArrayType = COMPONENT_ARRAYS[ accessor.componentType ];
 			const size = TYPE_SIZES[ accessor.type ];
+			if ( ! size ) throw new Error( `usd-gltf: accessor ${ index } has an invalid type` );
+			if ( ! ArrayType ) throw mismatch( { kind: 'component-type', semantic, accessor: index, declared: accessor.componentType } );
 			const attribute = decoder.GetAttributeByUniqueId( geometry, id );
-			if ( ! ArrayType || ! size || ! attribute || attribute.ptr === 0 ) throw new Error( `usd-gltf: Draco data has no ${ name } attribute ${ id }` );
-			if ( points !== accessor.count || attribute.num_components() !== size ) throw new Error( `usd-gltf: Draco ${ name } doesn't match accessor ${ index }` );
-			out.set( index, read( draco, points * size, ArrayType, budget, ( length, ptr ) => decoder.GetAttributeDataArrayForAllPoints( geometry, attribute, draco[ DATA_TYPES[ accessor.componentType ] ], length, ptr ) ) );
+			if ( ! attribute || attribute.ptr === 0 ) throw mismatch( { kind: 'attribute', semantic, accessor: index, declared: id } );
+			if ( attribute.num_components() !== size ) throw mismatch( { kind: 'components', semantic, accessor: index, declared: accessor.type, decoded: attribute.num_components() } );
+			put( semantic, index, read( draco, points * size, ArrayType, budget, ( length, ptr ) => decoder.GetAttributeDataArrayForAllPoints( geometry, attribute, draco[ DATA_TYPES[ accessor.componentType ] ], length, ptr ) ) );
 
 		}
 
 		if ( primitive.indices !== undefined && type === draco.TRIANGULAR_MESH ) {
 
 			const accessor = json.accessors[ primitive.indices ];
-			const count = geometry.num_faces() * 3;
-			if ( ! accessor || accessor.count !== count ) throw new Error( `usd-gltf: Draco indices don't match accessor ${ primitive.indices }` );
-			const indices = read( draco, count, Uint32Array, budget, ( length, ptr ) => decoder.GetTrianglesUInt32Array( geometry, length, ptr ) );
-			const IndexType = COMPONENT_ARRAYS[ accessor.componentType ] || Uint32Array;
-			out.set( primitive.indices, IndexType === Uint32Array ? indices : IndexType.from( indices ) );
+			if ( ! accessor ) throw new Error( `usd-gltf: accessor ${ primitive.indices } doesn't exist` );
+			indexCount = geometry.num_faces() * 3;
+			const indices = read( draco, indexCount, Uint32Array, budget, ( length, ptr ) => decoder.GetTrianglesUInt32Array( geometry, length, ptr ) );
+			let max = - 1;
+			for ( let i = 0; i < indices.length; i ++ ) if ( indices[ i ] > max ) max = indices[ i ];
+			if ( max >= points ) throw new Error( 'usd-gltf: Draco indices are out of range' );
+			const IndexType = INDEX_ARRAYS[ accessor.componentType ];
+			if ( ! IndexType || max > INDEX_MAX[ accessor.componentType ] ) throw mismatch( { kind: 'component-type', semantic: 'indices', accessor: primitive.indices, declared: accessor.componentType } );
+			put( 'indices', primitive.indices, IndexType === Uint32Array ? indices : IndexType.from( indices ) );
 
 		}
 
@@ -166,10 +218,172 @@ export function decodeDracoPrimitive( draco, bytes, json, primitive, budget ) {
 
 	}
 
+	return { points, indexCount, data };
+
+}
+
+/**
+ * Checks decoded primitives against their accessors and returns the accessor data. Count
+ * mismatches are errors, unless recoverCounts is set and everything else that depends on those
+ * counts agrees with the decoded data: then the accessors take the decoded counts, and log says so.
+ * @param {object} json changed only by recovered counts
+ * @param {Array<{ mesh: number, index: number, primitive: object, points: number, indexCount: number|null, data: Map<number, ArrayLike<number>> }>} decoded
+ * @param {{ recoverCounts?: boolean, log?: ( message: string ) => void }} [options]
+ * @returns {Map<number, ArrayLike<number>>}
+ */
+export function resolveDracoAccessors( json, decoded, { recoverCounts = false, log = () => {} } = {} ) {
+
+	const out = new Map();
+
+	for ( const d of decoded ) for ( const [ index, values ] of d.data ) {
+
+		if ( out.has( index ) && ! sameValues( out.get( index ), values ) ) throw new DracoMismatchError( { kind: 'shared-accessor', mesh: d.mesh, primitive: d.index, semantic: semanticOf( d.primitive, index ), accessor: index } );
+		out.set( index, values );
+
+	}
+
+	const uses = recoverCounts ? accessorUses( json ) : null;
+	const recovered = new Map(); // accessor -> decoded count
+
+	for ( const d of decoded ) {
+
+		const { primitive } = d;
+		const mismatches = [];
+
+		for ( const semantic of Object.keys( primitive.extensions.KHR_draco_mesh_compression.attributes ) ) {
+
+			const index = primitive.attributes[ semantic ];
+			const declared = json.accessors[ index ]?.count;
+			if ( index !== undefined && declared !== d.points ) mismatches.push( { kind: 'count', semantic, accessor: index, declared, decoded: d.points } );
+
+		}
+
+		const declaredIndices = d.indexCount !== null ? json.accessors[ primitive.indices ].count : null;
+		if ( declaredIndices !== d.indexCount ) mismatches.push( { kind: 'index-count', semantic: 'indices', accessor: primitive.indices, declared: declaredIndices, decoded: d.indexCount } );
+
+		if ( ! mismatches.length ) continue;
+		const fail = ( unrecoverable ) => new DracoMismatchError( { mesh: d.mesh, primitive: d.index, ...mismatches[ 0 ], unrecoverable } );
+		if ( ! recoverCounts ) throw fail( null );
+		const reason = unrecoverable( json, d, mismatches, uses, out );
+		if ( reason ) throw fail( reason );
+
+		for ( const m of mismatches ) recovered.set( m.accessor, m.decoded );
+		log( `Draco mesh ${ d.mesh } primitive ${ d.index }: using the decoded counts, ${ mismatches.map( ( m ) => `${ m.semantic } ${ m.decoded } where accessor ${ m.accessor } declares ${ m.declared }` ).join( ', ' ) }` );
+
+	}
+
+	for ( const [ index, count ] of recovered ) json.accessors[ index ].count = count;
 	return out;
 
 }
 
+// Why a primitive's mismatched counts can't be replaced by the decoded ones, or null when they can.
+function unrecoverable( json, d, mismatches, uses, decodedData ) {
+
+	const { primitive, points } = d;
+	const compressed = primitive.extensions.KHR_draco_mesh_compression.attributes;
+
+	for ( const m of mismatches ) {
+
+		if ( json.accessors[ m.accessor ].sparse ) return `accessor ${ m.accessor } is sparse`;
+		// other Draco primitives decoding the same data are checked on their own
+		const other = uses.get( m.accessor ).find( ( use ) => ! use.draco );
+		if ( other ) return `accessor ${ m.accessor } is also used by ${ other.what }`;
+
+	}
+
+	for ( const [ semantic, index ] of Object.entries( primitive.attributes ) ) {
+
+		const count = json.accessors[ index ]?.count;
+		if ( ! ( semantic in compressed ) && count !== points ) return `${ semantic } isn't Draco compressed and has ${ count } elements, not ${ points }`;
+
+	}
+
+	for ( const [ t, target ] of ( primitive.targets || [] ).entries() ) {
+
+		for ( const [ semantic, index ] of Object.entries( target ) ) {
+
+			const count = json.accessors[ index ]?.count;
+			if ( count !== points ) return `morph target ${ t } ${ semantic } has ${ count } elements, not ${ points }`;
+
+		}
+
+	}
+
+	const position = primitive.attributes.POSITION;
+
+	if ( mismatches.some( ( m ) => m.accessor === position ) ) {
+
+		// the bounds must still describe the decoded positions, allowing for 8 bits of Draco quantization over the largest extent
+		const { min, max } = json.accessors[ position ];
+		if ( ! ( min?.length === 3 && max?.length === 3 ) ) return `POSITION accessor ${ position } has no min and max to check the decoded positions against`;
+		const values = decodedData.get( position );
+		const lo = [ Infinity, Infinity, Infinity ], hi = [ - Infinity, - Infinity, - Infinity ];
+
+		for ( let i = 0; i < values.length; i += 3 ) for ( let c = 0; c < 3; c ++ ) {
+
+			lo[ c ] = Math.min( lo[ c ], values[ i + c ] );
+			hi[ c ] = Math.max( hi[ c ], values[ i + c ] );
+
+		}
+
+		const tolerance = Math.max( max[ 0 ] - min[ 0 ], max[ 1 ] - min[ 1 ], max[ 2 ] - min[ 2 ] ) / 256 + 1e-6;
+		for ( let c = 0; c < 3; c ++ ) if ( ! ( Math.abs( lo[ c ] - min[ c ] ) <= tolerance && Math.abs( hi[ c ] - max[ c ] ) <= tolerance ) ) return `the decoded positions don't match POSITION accessor ${ position }'s min and max`;
+
+	}
+
+	return null;
+
+}
+
+// Every reference to each accessor, marking those a Draco extension provides.
+function accessorUses( json ) {
+
+	const uses = new Map();
+	const add = ( accessor, what, draco ) => { if ( accessor !== undefined ) uses.set( accessor, [ ...( uses.get( accessor ) || [] ), { what, draco } ] ); };
+
+	( json.meshes || [] ).forEach( ( mesh, m ) => ( mesh.primitives || [] ).forEach( ( primitive, p ) => {
+
+		const draco = primitive.extensions?.KHR_draco_mesh_compression;
+		const where = `mesh ${ m } primitive ${ p }`;
+		for ( const [ semantic, a ] of Object.entries( primitive.attributes || {} ) ) add( a, `${ where } ${ semantic }`, !! draco && semantic in draco.attributes );
+		add( primitive.indices, `${ where } indices`, !! draco );
+		( primitive.targets || [] ).forEach( ( target, t ) => { for ( const [ semantic, a ] of Object.entries( target ) ) add( a, `${ where } morph target ${ t } ${ semantic }`, false ); } );
+
+	} ) );
+
+	( json.skins || [] ).forEach( ( skin, s ) => add( skin.inverseBindMatrices, `skin ${ s }`, false ) );
+	( json.animations || [] ).forEach( ( animation, a ) => ( animation.samplers || [] ).forEach( ( sampler, s ) => {
+
+		add( sampler.input, `animation ${ a } sampler ${ s }`, false );
+		add( sampler.output, `animation ${ a } sampler ${ s }`, false );
+
+	} ) );
+	( json.nodes || [] ).forEach( ( node, n ) => {
+
+		for ( const a of Object.values( node.extensions?.EXT_mesh_gpu_instancing?.attributes || {} ) ) add( a, `node ${ n } instancing`, false );
+
+	} );
+
+	return uses;
+
+}
+
+function semanticOf( primitive, accessor ) {
+
+	if ( primitive.indices === accessor ) return 'indices';
+	return Object.keys( primitive.attributes ).find( ( s ) => primitive.attributes[ s ] === accessor );
+
+}
+
+function sameValues( a, b ) {
+
+	if ( a.length !== b.length || a.constructor !== b.constructor ) return false;
+	for ( let i = 0; i < a.length; i ++ ) if ( ! Object.is( a[ i ], b[ i ] ) ) return false;
+	return true;
+
+}
+
 // Has the decoder fill a buffer on its heap, then copies it out.
 function read( draco, count, ArrayType, budget, fill ) {
 

package/src/index.d.ts

@@ -34,6 +34,34 @@ export class ConversionLimitError extends Error {
 	attempted: number;
 }
 
+/**
+ * Thrown when decoded Draco data doesn't match the accessors describing it. With recoverDracoCounts,
+ * count mismatches that can't be checked still throw, with unrecoverable saying why.
+ */
+export class DracoMismatchError extends Error {
+	name: 'DracoMismatchError';
+	code: 'USD_GLTF_DRACO_MISMATCH';
+	/**
+	 * count / index-count: a different number of elements or indices than declared;
+	 * components: a different number of components than the accessor type has;
+	 * component-type: values the accessor's componentType can't hold;
+	 * attribute: no Draco attribute with the extension's id;
+	 * shared-accessor: one accessor decoded more than once to different data.
+	 */
+	kind: 'count' | 'index-count' | 'components' | 'component-type' | 'attribute' | 'shared-accessor';
+	mesh: number;
+	primitive: number;
+	/** The attribute semantic, e.g. 'POSITION', or 'indices'. */
+	semantic: string;
+	accessor: number;
+	/** What the accessor declares: its count, type, componentType, or the Draco attribute id. */
+	declared?: number | string;
+	/** What the Draco data has: a count of elements, indices or components. */
+	decoded?: number;
+	/** With recoverDracoCounts, why the decoded counts couldn't be used. */
+	unrecoverable: string | null;
+}
+
 export interface USDToGLBOptions extends ConversionLimits {
 	/** Name of the input file, used to resolve relative paths. */
 	identifier?: string;
@@ -58,7 +86,14 @@ export interface GLBToUSDOptions extends ConversionLimits {
 	 * promise of one. Without it, Draco files load draco3d in Node and Google's CDN build in browsers.
 	 */
 	dracoDecoder?: object | Promise<object>;
+	/**
+	 * Use decoded Draco counts that disagree with their accessors' counts, which the extension
+	 * doesn't allow, when everything else depending on them can be checked against the decoded data.
+	 * Each recovery is reported through log. Default false: such files throw a DracoMismatchError.
+	 */
+	recoverDracoCounts?: boolean;
 	imageDecoder?: ImageDecoder;
+	/** Receives non fatal problems, such as textures that could not be read or recovered Draco counts. */
 	log?: ( message: string ) => void;
 }
 

package/src/index.js

@@ -15,6 +15,7 @@ export { writeUSDA } from './usd/usda/writer.js';
 export { readUSDC } from './usd/usdc/reader.js';
 export { writeUSDC } from './usd/usdc/writer.js';
 export { ConversionLimitError } from './limits.js';
+export { DracoMismatchError } from './gltf/draco.js';
 
 function toBytes( data ) {
 
@@ -50,13 +51,13 @@ export async function usdToGLB( data, options = {} ) {
 /**
  * Converts GLB (or glTF JSON with embedded or resolvable buffers) to USD.
  * @param {ArrayBuffer|Uint8Array} data
- * @param {{ format?: 'usda'|'usdc'|'usdz', resolver?: ( uri: string ) => Promise<Uint8Array>, dracoDecoder?: object, maxDecodedBytes?: number, maxOutputBytes?: number, signal?: AbortSignal }} [options]
+ * @param {{ format?: 'usda'|'usdc'|'usdz', resolver?: ( uri: string ) => Promise<Uint8Array>, dracoDecoder?: object, recoverDracoCounts?: boolean, log?: ( message: string ) => void, maxDecodedBytes?: number, maxOutputBytes?: number, signal?: AbortSignal }} [options]
  * @returns {Promise<Uint8Array>}
  */
-export async function glbToUSD( data, { format = 'usdz', resolver = null, log, imageDecoder, dracoDecoder, ...limits } = {} ) {
+export async function glbToUSD( data, { format = 'usdz', resolver = null, log, imageDecoder, dracoDecoder, recoverDracoCounts, ...limits } = {} ) {
 
 	const budget = budgetFor( limits );
-	const doc = await readGLTF( toBytes( data ), { resolver, budget, dracoDecoder } );
+	const doc = await readGLTF( toBytes( data ), { resolver, budget, dracoDecoder, recoverDracoCounts, log } );
 	const { layer, files } = await new GLTFToUSD( doc, { log, imageDecoder } ).convert();
 	let out;
 
@@ -73,10 +74,10 @@ export async function glbToUSD( data, { format = 'usdz', resolver = null, log, i
  * For usda / usdc output the textures are separate files; this returns them alongside the layer.
  * @returns {Promise<{ layer: Uint8Array, files: Array<{ name: string, data: Uint8Array }> }>}
  */
-export async function glbToUSDFiles( data, { format = 'usda', resolver = null, log, imageDecoder, dracoDecoder, ...limits } = {} ) {
+export async function glbToUSDFiles( data, { format = 'usda', resolver = null, log, imageDecoder, dracoDecoder, recoverDracoCounts, ...limits } = {} ) {
 
 	const budget = budgetFor( limits );
-	const doc = await readGLTF( toBytes( data ), { resolver, budget, dracoDecoder } );
+	const doc = await readGLTF( toBytes( data ), { resolver, budget, dracoDecoder, recoverDracoCounts, log } );
 	const { layer, files } = await new GLTFToUSD( doc, { log, imageDecoder } ).convert();
 	const bytes = format === 'usdc' ? writeUSDC( layer, { budget } ) : new TextEncoder().encode( writeUSDA( layer, { budget } ) );
 	budget.output( files.reduce( ( n, f ) => n + f.data.byteLength, bytes.byteLength ), 'usd files' );