@openusd-wasm/three-loader 0.0.1

package/dist/openusd_three_loader.js

@@ -0,0 +1,2148 @@
+import { createPxr } from "@openusd-wasm/pxr";
+import * as THREE from "three";
+import { FileLoader, Loader } from "three";
+//#region src/asset-resolver.ts
+const DEFAULT_ASSET_SEARCH_EXTENSIONS = [
+	".usd",
+	".usda",
+	".usdc",
+	".usdz",
+	".png",
+	".jpg",
+	".jpeg",
+	".webp",
+	".ktx2",
+	".exr",
+	".hdr"
+];
+const DEFAULT_ASSET_SEARCH_ROOTS = [
+	"resource",
+	"resources",
+	"asset",
+	"assets",
+	"img",
+	"image",
+	"images",
+	"texture",
+	"textures",
+	"material",
+	"materials"
+];
+const DEFAULT_MAX_ASSET_REFERENCES = 80;
+const DEFAULT_MAX_ASSET_REFERENCE_DEPTH = 4;
+function toFetchableUrl(value) {
+	try {
+		const url = new URL(value, globalThis.location?.href);
+		return url.protocol === "http:" || url.protocol === "https:" || url.protocol === "file:" ? url.href : null;
+	} catch {
+		return null;
+	}
+}
+function normalizeFsRelativePath(path) {
+	const parts = [];
+	for (const part of path.replaceAll("\\", "/").split("/")) {
+		if (!part || part === ".") continue;
+		if (part === "..") {
+			parts.pop();
+			continue;
+		}
+		parts.push(part);
+	}
+	return parts.join("/");
+}
+function dirname(path) {
+	const normalized = normalizeFsRelativePath(path);
+	const index = normalized.lastIndexOf("/");
+	return index === -1 ? "" : normalized.slice(0, index);
+}
+function joinRelativePath(base, path) {
+	return normalizeFsRelativePath(base ? `${base}/${path}` : path);
+}
+function extensionOf(path) {
+	const match = /\.([A-Za-z0-9]+)$/.exec(path.split(/[?#]/)[0] ?? path);
+	return match ? `.${match[1]?.toLowerCase()}` : "";
+}
+function contentTypeForPath(path) {
+	switch (extensionOf(path)) {
+		case ".png": return "image/png";
+		case ".jpg":
+		case ".jpeg": return "image/jpeg";
+		case ".webp": return "image/webp";
+		default: return "application/octet-stream";
+	}
+}
+function baseName(path) {
+	return normalizeFsRelativePath(path).split("/").pop() ?? "";
+}
+function fileNameForSource$1(sourcePath) {
+	const name = (sourcePath.split(/[?#]/)[0] ?? sourcePath).split("/").filter(Boolean).pop();
+	return name && /\.[a-z0-9]+$/i.test(name) ? name : "scene.usda";
+}
+function toArrayBuffer(data) {
+	const buffer = new ArrayBuffer(data.byteLength);
+	new Uint8Array(buffer).set(data);
+	return buffer;
+}
+function trimAssetReference(value) {
+	let ref = value.trim();
+	if (!ref || ref.length > 220) return null;
+	ref = ref.replace(/^[@<"']+/, "").replace(/[@>"')\]},;]+$/g, "");
+	if (!ref || ref.startsWith("#") || ref.startsWith("$")) return null;
+	if (/^[A-Za-z]:[\\/]/.test(ref)) return null;
+	if (/^[A-Za-z][A-Za-z0-9+.-]*:/.test(ref)) return null;
+	if (ref.startsWith("/")) return null;
+	if (ref.includes("\0") || /\s/.test(ref)) return null;
+	if (!/^[A-Za-z0-9._~!$&'()+,;=@/-]+$/.test(ref)) return null;
+	return ref;
+}
+function isUsdCrate(data) {
+	return data[0] === 80 && data[1] === 88 && data[2] === 82 && data[3] === 45 && data[4] === 85 && data[5] === 83 && data[6] === 68 && data[7] === 67;
+}
+function startsWithAssetSearchRoot(value) {
+	return /^(resource|resources|asset|assets|img|image|images|texture|textures|material|materials)(\/|$)/i.test(value);
+}
+function startsWithAssetSearchRootPath(value) {
+	const normalized = normalizeFsRelativePath(value);
+	return normalized.includes("/") && startsWithAssetSearchRoot(normalized);
+}
+function looksLikeExtensionlessAssetPath(value) {
+	const parts = normalizeFsRelativePath(value).split("/");
+	if (parts.length < 2 || parts.length > 3) return false;
+	if (parts.some((part) => part.length < 2 || part.length > 80)) return false;
+	if (parts.some((part) => part.startsWith("."))) return false;
+	if (parts.some((part) => !/^[A-Za-z0-9._-]+$/.test(part))) return false;
+	if (!/_/.test(value) || !/\d/.test(value)) return false;
+	return true;
+}
+function looksLikeKnownExtensionlessAsset(value) {
+	const normalized = normalizeFsRelativePath(value);
+	if (!normalized.includes("/")) return false;
+	return [
+		"material",
+		"model",
+		"scene"
+	].includes(baseName(normalized).toLowerCase());
+}
+function looksLikeAssetReference(value, searchExtensions, includeExtensionlessAssetPaths, wholeString) {
+	const extension = extensionOf(value);
+	if (extension) {
+		if (!searchExtensions.includes(extension)) return false;
+		const name = baseName(value);
+		if (name === extension) return false;
+		if (wholeString && !value.startsWith("./") && !value.startsWith("../") && !value.includes("/")) return name.length >= 8;
+		return true;
+	}
+	if (value.startsWith("./") || value.startsWith("../")) {
+		const relative = normalizeFsRelativePath(value);
+		if (startsWithAssetSearchRootPath(relative)) return looksLikeExtensionlessAssetPath(relative) || looksLikeKnownExtensionlessAsset(relative);
+		return looksLikeExtensionlessAssetPath(relative);
+	}
+	if (startsWithAssetSearchRootPath(value)) return looksLikeExtensionlessAssetPath(value) || looksLikeKnownExtensionlessAsset(value);
+	return includeExtensionlessAssetPaths && looksLikeExtensionlessAssetPath(value);
+}
+function extractAsciiStrings(data) {
+	const strings = [];
+	let current = "";
+	for (const byte of data) if (byte >= 32 && byte <= 126) current += String.fromCharCode(byte);
+	else {
+		if (current.length >= 4) strings.push(current);
+		current = "";
+	}
+	if (current.length >= 4) strings.push(current);
+	return strings;
+}
+function discoverAssetReferences(data, searchExtensions, includeExtensionlessAssetPaths = false) {
+	const out = /* @__PURE__ */ new Set();
+	for (const text of extractAsciiStrings(data)) {
+		const whole = trimAssetReference(text);
+		if (whole && looksLikeAssetReference(whole, searchExtensions, includeExtensionlessAssetPaths, true)) out.add(whole);
+		for (const match of text.matchAll(/@([^@\n\r]+)@/g)) {
+			const ref = trimAssetReference(match[1] ?? "");
+			if (ref && looksLikeAssetReference(ref, searchExtensions, includeExtensionlessAssetPaths, false)) out.add(ref);
+		}
+		for (const match of text.matchAll(/["']([^"'\n\r]+\.(?:usd|usda|usdc|usdz|png|jpe?g|webp|ktx2|exr|hdr|mdl))["']/gi)) {
+			const ref = trimAssetReference(match[1] ?? "");
+			if (ref && looksLikeAssetReference(ref, searchExtensions, includeExtensionlessAssetPaths, false)) out.add(ref);
+		}
+	}
+	return [...out];
+}
+function discoverAssetSearchRoots(data, searchRoots) {
+	const out = /* @__PURE__ */ new Set();
+	const rootSet = new Set(searchRoots);
+	for (const text of extractAsciiStrings(data)) {
+		const ref = trimAssetReference(text);
+		if (!ref) continue;
+		const segment = firstPathSegment(ref);
+		if (rootSet.has(segment) && normalizeFsRelativePath(ref).includes("/")) out.add(segment);
+	}
+	return [...out];
+}
+function buildExtensionVariants(path, searchExtensions) {
+	const normalized = normalizeFsRelativePath(path);
+	if (!normalized) return [];
+	if (extensionOf(normalized)) return [normalized];
+	return [...searchExtensions.map((extension) => `${normalized}${extension}`), normalized];
+}
+function buildReferencePathVariants(relativePath) {
+	const normalized = normalizeFsRelativePath(relativePath);
+	if (!normalized) return [];
+	return [{
+		path: normalized,
+		aliases: [normalized]
+	}];
+}
+function unique(values) {
+	return [...new Set(values)];
+}
+function uniqueFileCount(files) {
+	return new Set(Object.values(files)).size;
+}
+function firstPathSegment(path) {
+	return normalizeFsRelativePath(path).split("/")[0] ?? "";
+}
+function normalizeSearchRoots(roots) {
+	return unique((roots ?? DEFAULT_ASSET_SEARCH_ROOTS).map((root) => normalizeFsRelativePath(root)).filter(Boolean));
+}
+function inferReferencedSearchRoots(refs, searchRoots) {
+	const rootSet = new Set(searchRoots);
+	return unique(refs.map((ref) => firstPathSegment(ref)).filter((segment) => rootSet.has(segment)));
+}
+function buildFetchAttempts(ref, sourceUrl, sourceRelativePath, searchExtensions, rootSourceUrl, searchRoots) {
+	const sourceDir = dirname(sourceRelativePath);
+	const attempts = [];
+	const seen = /* @__PURE__ */ new Set();
+	const normalizedRef = normalizeFsRelativePath(ref);
+	const isDotRelative = /^\.{1,2}\//.test(ref);
+	const candidates = [];
+	function addCandidate(fsPath, fetchPath, baseUrl, aliases = []) {
+		const normalizedFsPath = normalizeFsRelativePath(fsPath);
+		if (!normalizedFsPath) return;
+		candidates.push({
+			fsPath: normalizedFsPath,
+			fetchPath,
+			baseUrl,
+			aliases: unique([
+				normalizedRef,
+				normalizedFsPath,
+				...aliases
+			].filter(Boolean))
+		});
+	}
+	if (!isDotRelative) {
+		for (const root of searchRoots) if (normalizedRef !== root && !normalizedRef.startsWith(`${root}/`)) addCandidate(`${root}/${normalizedRef}`, `${root}/${normalizedRef}`, rootSourceUrl);
+	}
+	addCandidate(joinRelativePath(sourceDir, ref), ref, sourceUrl);
+	if (!isDotRelative && sourceDir) addCandidate(normalizedRef, normalizedRef, rootSourceUrl);
+	for (const candidate of candidates) for (const variant of buildReferencePathVariants(candidate.fsPath)) {
+		const fsAliases = new Set([...candidate.aliases, ...variant.aliases]);
+		for (const pathWithExtension of buildExtensionVariants(variant.path, searchExtensions)) {
+			const extension = extensionOf(pathWithExtension);
+			fsAliases.add(pathWithExtension);
+			const fetchPath = extensionOf(candidate.fetchPath) ? candidate.fetchPath : `${candidate.fetchPath}${extension}`;
+			try {
+				const url = new URL(fetchPath, candidate.baseUrl).href;
+				if (seen.has(url)) continue;
+				seen.add(url);
+				attempts.push({
+					url,
+					fsPaths: [...fsAliases]
+				});
+			} catch {}
+		}
+	}
+	return attempts;
+}
+async function fetchBinary(url) {
+	try {
+		const response = await fetch(url);
+		if (!response.ok) return null;
+		return new Uint8Array(await response.arrayBuffer());
+	} catch {
+		return null;
+	}
+}
+async function autoResolveAssetFiles(rootData, options) {
+	const sourcePath = options.sourcePath ?? "";
+	if (options.autoResolveAssets === false || !sourcePath) return {};
+	const sourceUrl = toFetchableUrl(sourcePath);
+	if (!sourceUrl) return {};
+	const searchExtensions = options.assetSearchExtensions ?? DEFAULT_ASSET_SEARCH_EXTENSIONS;
+	const configuredSearchRoots = normalizeSearchRoots(options.assetSearchRoots);
+	const maxFiles = options.maxAssetReferences ?? DEFAULT_MAX_ASSET_REFERENCES;
+	const maxDepth = options.maxAssetReferenceDepth ?? DEFAULT_MAX_ASSET_REFERENCE_DEPTH;
+	const rootRelativePath = normalizeFsRelativePath(options.fileName ?? fileNameForSource$1(sourcePath));
+	const files = {};
+	const fetchedUrls = /* @__PURE__ */ new Set();
+	const queued = /* @__PURE__ */ new Set();
+	const rootRefs = discoverAssetReferences(rootData, searchExtensions, true);
+	const inferredSearchRoots = unique([...inferReferencedSearchRoots(rootRefs, configuredSearchRoots), ...discoverAssetSearchRoots(rootData, configuredSearchRoots)]);
+	const queue = rootRefs.map((ref) => ({
+		ref,
+		sourceUrl,
+		rootSourceUrl: sourceUrl,
+		sourceRelativePath: rootRelativePath,
+		searchRoots: inferredSearchRoots,
+		depth: 0
+	}));
+	for (const item of queue) queued.add(`${item.sourceUrl}\n${item.ref}`);
+	while (queue.length > 0 && uniqueFileCount(files) < maxFiles) {
+		const item = queue.shift();
+		if (!item || item.depth > maxDepth) continue;
+		for (const attempt of buildFetchAttempts(item.ref, item.sourceUrl, item.sourceRelativePath, searchExtensions, item.rootSourceUrl, item.searchRoots)) {
+			if (fetchedUrls.has(attempt.url)) continue;
+			fetchedUrls.add(attempt.url);
+			const data = await fetchBinary(attempt.url);
+			if (!data) continue;
+			for (const fsPath of attempt.fsPaths) files[fsPath] = data;
+			if (item.depth < maxDepth) {
+				const sourceRelativePath = attempt.fsPaths.find((path) => extensionOf(path)) ?? attempt.fsPaths[0];
+				if (sourceRelativePath) for (const ref of discoverAssetReferences(data, searchExtensions, !isUsdCrate(data))) {
+					const queueKey = `${attempt.url}\n${ref}`;
+					if (queued.has(queueKey)) continue;
+					queued.add(queueKey);
+					const nestedSearchRoots = unique([...item.searchRoots, ...inferReferencedSearchRoots([sourceRelativePath], configuredSearchRoots)]);
+					queue.push({
+						ref,
+						sourceUrl: attempt.url,
+						rootSourceUrl: item.rootSourceUrl,
+						sourceRelativePath,
+						searchRoots: nestedSearchRoots,
+						depth: item.depth + 1
+					});
+				}
+			}
+			break;
+		}
+	}
+	return files;
+}
+function isTextureAssetReference(value) {
+	if (/^(blob|data):/i.test(value)) return false;
+	if (/^[A-Za-z][A-Za-z0-9+.-]*:/.test(value)) return false;
+	if (value.startsWith("/")) return false;
+	return [
+		".png",
+		".jpg",
+		".jpeg",
+		".webp"
+	].includes(extensionOf(value));
+}
+function collectTextureAssetReferences(value, refs = /* @__PURE__ */ new Set()) {
+	if (!value) return refs;
+	if (Array.isArray(value)) {
+		for (const item of value) collectTextureAssetReferences(item, refs);
+		return refs;
+	}
+	if (typeof value !== "object") return refs;
+	const asset = value;
+	for (const item of [asset.path, asset.url]) if (typeof item === "string" && isTextureAssetReference(item)) refs.add(item);
+	for (const item of Object.values(value)) collectTextureAssetReferences(item, refs);
+	return refs;
+}
+async function autoResolveTextureFiles(metadata, existingFiles, options) {
+	const sourcePath = options.sourcePath ?? "";
+	if (options.autoResolveAssets === false || !sourcePath) return {};
+	const sourceUrl = toFetchableUrl(sourcePath);
+	if (!sourceUrl) return {};
+	const searchExtensions = options.assetSearchExtensions ?? DEFAULT_ASSET_SEARCH_EXTENSIONS;
+	const configuredSearchRoots = normalizeSearchRoots(options.assetSearchRoots);
+	const textureRefs = [...collectTextureAssetReferences(metadata)];
+	const searchRoots = unique([...inferReferencedSearchRoots(Object.keys(existingFiles), configuredSearchRoots), ...inferReferencedSearchRoots(textureRefs, configuredSearchRoots)]);
+	const maxFiles = options.maxAssetReferences ?? DEFAULT_MAX_ASSET_REFERENCES;
+	const remainingFiles = Math.max(maxFiles - uniqueFileCount(existingFiles), 0);
+	if (remainingFiles === 0) return {};
+	const rootRelativePath = normalizeFsRelativePath(options.fileName ?? fileNameForSource$1(sourcePath));
+	const files = {};
+	const fetchedUrls = /* @__PURE__ */ new Set();
+	let resolvedFiles = 0;
+	for (const ref of textureRefs) {
+		if (resolvedFiles >= remainingFiles) break;
+		for (const attempt of buildFetchAttempts(ref, sourceUrl, rootRelativePath, searchExtensions, sourceUrl, searchRoots)) {
+			if (attempt.fsPaths.some((path) => existingFiles[path] || files[path])) break;
+			if (fetchedUrls.has(attempt.url)) continue;
+			fetchedUrls.add(attempt.url);
+			const data = await fetchBinary(attempt.url);
+			if (!data) continue;
+			for (const fsPath of attempt.fsPaths) files[fsPath] = data;
+			resolvedFiles += 1;
+			break;
+		}
+	}
+	return files;
+}
+function readZipEntryName(data, start, length) {
+	return new TextDecoder().decode(data.subarray(start, start + length));
+}
+function extractStoredZipEntries(data) {
+	const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	const entries = /* @__PURE__ */ new Map();
+	let offset = 0;
+	while (offset + 30 <= data.byteLength) {
+		if (view.getUint32(offset, true) !== 67324752) break;
+		const method = view.getUint16(offset + 8, true);
+		const compressedSize = view.getUint32(offset + 18, true);
+		const fileNameLength = view.getUint16(offset + 26, true);
+		const extraLength = view.getUint16(offset + 28, true);
+		const nameStart = offset + 30;
+		const dataStart = nameStart + fileNameLength + extraLength;
+		const dataEnd = dataStart + compressedSize;
+		if (dataEnd > data.byteLength) break;
+		const name = normalizeFsRelativePath(readZipEntryName(data, nameStart, fileNameLength));
+		if (name && method === 0) entries.set(name, data.slice(dataStart, dataEnd));
+		offset = dataEnd;
+	}
+	return entries;
+}
+function createTextureResolverFromEntries(entries) {
+	if (typeof Blob === "undefined" || typeof URL === "undefined" || typeof URL.createObjectURL !== "function") return null;
+	const imageEntries = new Map([...entries].filter(([path]) => [
+		".png",
+		".jpg",
+		".jpeg",
+		".webp"
+	].includes(extensionOf(path))));
+	if (imageEntries.size === 0) return null;
+	const byBaseName = /* @__PURE__ */ new Map();
+	for (const path of imageEntries.keys()) {
+		const name = baseName(path);
+		byBaseName.set(name, byBaseName.has(name) ? null : path);
+	}
+	const urls = /* @__PURE__ */ new Map();
+	const urlForEntry = (path) => {
+		const entry = imageEntries.get(path);
+		if (!entry) return null;
+		let url = urls.get(path);
+		if (!url) {
+			url = URL.createObjectURL(new Blob([toArrayBuffer(entry)], { type: contentTypeForPath(path) }));
+			urls.set(path, url);
+		}
+		return url;
+	};
+	const resolvePath = (value) => {
+		if (!value) return null;
+		const normalized = normalizeFsRelativePath(value.split(/[?#]/)[0] ?? value);
+		if (!normalized) return null;
+		if (imageEntries.has(normalized)) return urlForEntry(normalized);
+		const suffixMatches = [...imageEntries.keys()].filter((path) => path.endsWith(`/${normalized}`));
+		if (suffixMatches.length === 1 && suffixMatches[0]) return urlForEntry(suffixMatches[0]);
+		const virtualFsMatches = [...imageEntries.keys()].filter((path) => normalized.endsWith(`/${path}`));
+		if (virtualFsMatches.length === 1 && virtualFsMatches[0]) return urlForEntry(virtualFsMatches[0]);
+		const uniqueBaseName = byBaseName.get(baseName(normalized));
+		return uniqueBaseName ? urlForEntry(uniqueBaseName) : null;
+	};
+	return {
+		urls,
+		resolve(asset) {
+			return resolvePath(asset.resolvedPath) ?? resolvePath(asset.path) ?? resolvePath(asset.url) ?? null;
+		}
+	};
+}
+function createPackageTextureResolver(data) {
+	return createTextureResolverFromEntries(extractStoredZipEntries(data));
+}
+//#endregion
+//#region src/metadata.ts
+const MATERIAL_INPUT_SUFFIXES = [
+	"diffuseColor",
+	"base_color",
+	"baseColor",
+	"emissiveColor",
+	"normal",
+	"occlusion",
+	"opacity",
+	"alpha",
+	"roughness",
+	"metallic",
+	"metallicFactor",
+	"file",
+	"wrapS",
+	"wrapT",
+	"scale",
+	"translation",
+	"rotation"
+];
+const JOINT_TYPES = {
+	PhysicsFixedJoint: "fixed",
+	PhysicsRevoluteJoint: "revolute",
+	PhysicsPrismaticJoint: "prismatic",
+	PhysicsSphericalJoint: "spherical",
+	PhysicsDistanceJoint: "distance",
+	PhysicsJoint: "joint"
+};
+function dispose$1(value) {
+	if (value && typeof value === "object" && "delete" in value && typeof value.delete === "function") value.delete();
+}
+function disposeAll(values) {
+	for (let i = values.length - 1; i >= 0; --i) dispose$1(values[i]);
+}
+function isValid$1(value) {
+	if (!value) return false;
+	if (typeof value.IsValid === "function") return Boolean(value.IsValid());
+	if (typeof value.IsDefined === "function") return Boolean(value.IsDefined());
+	return true;
+}
+function asFiniteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function normalizeValue(value) {
+	if (typeof value === "number") return Number.isFinite(value) ? value : null;
+	if (Array.isArray(value)) return value.map((item) => normalizeValue(item));
+	if (value && typeof value === "object") {
+		const out = {};
+		for (const [key, item] of Object.entries(value)) out[key] = normalizeValue(item);
+		return out;
+	}
+	return value;
+}
+function toArray(value) {
+	return Array.isArray(value) ? value : [];
+}
+function toNumberArray(value) {
+	return toArray(value).map((item) => Number(item)).filter((item) => Number.isFinite(item));
+}
+function toVector3(value, fallback) {
+	const numbers = toNumberArray(value);
+	if (numbers.length < 3) return fallback;
+	return [
+		numbers[0] ?? fallback[0],
+		numbers[1] ?? fallback[1],
+		numbers[2] ?? fallback[2]
+	];
+}
+function toVector4(value) {
+	if (Array.isArray(value)) {
+		const numbers = toNumberArray(value);
+		if (numbers.length >= 4) return [
+			numbers[0] ?? 1,
+			numbers[1] ?? 0,
+			numbers[2] ?? 0,
+			numbers[3] ?? 0
+		];
+	}
+	if (value && typeof value === "object") {
+		const { real, imaginary } = value;
+		const imaginaryNumbers = toNumberArray(imaginary);
+		const r = asFiniteNumber(real);
+		if (r !== null && imaginaryNumbers.length >= 3) return [
+			r,
+			imaginaryNumbers[0] ?? 0,
+			imaginaryNumbers[1] ?? 0,
+			imaginaryNumbers[2] ?? 0
+		];
+	}
+	return null;
+}
+function identityMatrix() {
+	return [
+		1,
+		0,
+		0,
+		0,
+		0,
+		1,
+		0,
+		0,
+		0,
+		0,
+		1,
+		0,
+		0,
+		0,
+		0,
+		1
+	];
+}
+function multiplyMatrices(a, b) {
+	const out = new Array(16).fill(0);
+	for (let row = 0; row < 4; row += 1) for (let column = 0; column < 4; column += 1) out[row * 4 + column] = (a[row * 4] ?? 0) * (b[column] ?? 0) + (a[row * 4 + 1] ?? 0) * (b[4 + column] ?? 0) + (a[row * 4 + 2] ?? 0) * (b[8 + column] ?? 0) + (a[row * 4 + 3] ?? 0) * (b[12 + column] ?? 0);
+	return out;
+}
+function matricesNearlyEqual(a, b) {
+	if (!a || !b || a.length < 16 || b.length < 16) return false;
+	return a.every((value, index) => Math.abs(value - (b[index] ?? 0)) < 1e-8);
+}
+function matrixFromXformOp(opName, value) {
+	const numbers = toNumberArray(value);
+	if (numbers.length === 0) return null;
+	if (opName.startsWith("xformOp:transform")) return numbers.length >= 16 ? numbers.slice(0, 16) : null;
+	if (opName.startsWith("xformOp:translate")) return [
+		1,
+		0,
+		0,
+		0,
+		0,
+		1,
+		0,
+		0,
+		0,
+		0,
+		1,
+		0,
+		numbers[0] ?? 0,
+		numbers[1] ?? 0,
+		numbers[2] ?? 0,
+		1
+	];
+	if (opName.startsWith("xformOp:scale")) return [
+		numbers[0] ?? 1,
+		0,
+		0,
+		0,
+		0,
+		numbers[1] ?? numbers[0] ?? 1,
+		0,
+		0,
+		0,
+		0,
+		numbers[2] ?? numbers[0] ?? 1,
+		0,
+		0,
+		0,
+		0,
+		1
+	];
+	if (opName.startsWith("xformOp:rotate")) return rotationMatrixFromXformOp(opName, numbers);
+	return null;
+}
+function rotationMatrixFromXformOp(opName, degrees) {
+	const rotateX = (degree) => {
+		const radians = degree * Math.PI / 180;
+		const cos = Math.cos(radians);
+		const sin = Math.sin(radians);
+		return [
+			1,
+			0,
+			0,
+			0,
+			0,
+			cos,
+			sin,
+			0,
+			0,
+			-sin,
+			cos,
+			0,
+			0,
+			0,
+			0,
+			1
+		];
+	};
+	const rotateY = (degree) => {
+		const radians = degree * Math.PI / 180;
+		const cos = Math.cos(radians);
+		const sin = Math.sin(radians);
+		return [
+			cos,
+			0,
+			-sin,
+			0,
+			0,
+			1,
+			0,
+			0,
+			sin,
+			0,
+			cos,
+			0,
+			0,
+			0,
+			0,
+			1
+		];
+	};
+	const rotateZ = (degree) => {
+		const radians = degree * Math.PI / 180;
+		const cos = Math.cos(radians);
+		const sin = Math.sin(radians);
+		return [
+			cos,
+			sin,
+			0,
+			0,
+			-sin,
+			cos,
+			0,
+			0,
+			0,
+			0,
+			1,
+			0,
+			0,
+			0,
+			0,
+			1
+		];
+	};
+	const suffix = opName.split(":")[1] ?? "";
+	if (suffix === "rotateX") return rotateX(degrees[0] ?? 0);
+	if (suffix === "rotateY") return rotateY(degrees[0] ?? 0);
+	if (suffix === "rotateZ") return rotateZ(degrees[0] ?? 0);
+	const axes = suffix.replace(/^rotate/, "").split("");
+	if (axes.length === 0) return null;
+	return axes.reduce((matrix, axis, index) => {
+		const degree = degrees[index] ?? 0;
+		const next = axis === "X" ? rotateX(degree) : axis === "Y" ? rotateY(degree) : axis === "Z" ? rotateZ(degree) : null;
+		return next ? multiplyMatrices(matrix, next) : matrix;
+	}, identityMatrix());
+}
+function attr(prim, name, time, defaultValue = null) {
+	const attribute = prim.GetAttribute(name);
+	try {
+		if (!isValid$1(attribute)) return defaultValue;
+		const value = attribute.Get(time);
+		return value === null || value === void 0 ? defaultValue : normalizeValue(value);
+	} finally {
+		dispose$1(attribute);
+	}
+}
+function attrMetadata(prim, name, key, defaultValue = null) {
+	const attribute = prim.GetAttribute(name);
+	try {
+		if (!isValid$1(attribute)) return defaultValue;
+		const value = attribute.GetMetadata(key);
+		return value === null || value === void 0 ? defaultValue : normalizeValue(value);
+	} finally {
+		dispose$1(attribute);
+	}
+}
+function relationshipTargets(prim, name) {
+	const relationship = prim.GetRelationship(name);
+	try {
+		if (!isValid$1(relationship)) return [];
+		const targets = relationship.GetTargets();
+		return Array.isArray(targets) ? targets.map(String) : [];
+	} finally {
+		dispose$1(relationship);
+	}
+}
+function connectionSourcePath(attribute) {
+	const connections = attribute.GetConnections();
+	if (!Array.isArray(connections) || connections.length === 0) return null;
+	return String(connections[0]).split(".outputs:")[0] ?? null;
+}
+function primChildren(prim) {
+	const children = prim.GetChildren();
+	return Array.isArray(children) ? children : [];
+}
+function primAtPath(pxr, stage, path) {
+	const sdfPath = new pxr.Sdf.Path(path);
+	try {
+		return stage.GetPrimAtPath(sdfPath);
+	} finally {
+		dispose$1(sdfPath);
+	}
+}
+function materialBinding(prim) {
+	let current = prim;
+	let ownsCurrent = false;
+	try {
+		while (current && !current.IsPseudoRoot()) {
+			const targets = relationshipTargets(current, "material:binding");
+			if (targets.length > 0) return targets[0] ?? null;
+			const parent = current.GetParent();
+			if (ownsCurrent) dispose$1(current);
+			current = parent;
+			ownsCurrent = true;
+		}
+		return null;
+	} finally {
+		if (ownsCurrent) dispose$1(current);
+	}
+}
+function localTransformForPrim(pxr, prim) {
+	if (!prim.IsA("Xformable")) return {
+		localMatrix: null,
+		resetsXformStack: false
+	};
+	const xformable = new pxr.UsdGeom.Xformable(prim);
+	try {
+		if (!isValid$1(xformable)) return {
+			localMatrix: null,
+			resetsXformStack: false
+		};
+		const transform = xformable.GetLocalTransformation();
+		return {
+			localMatrix: toNumberArray(transform?.matrix),
+			resetsXformStack: Boolean(transform?.resetsXformStack)
+		};
+	} finally {
+		dispose$1(xformable);
+	}
+}
+function parentPathForPrim(prim) {
+	const parent = prim.GetParent();
+	try {
+		if (!isValid$1(parent) || parent.IsPseudoRoot()) return null;
+		return String(parent.GetPath());
+	} finally {
+		dispose$1(parent);
+	}
+}
+function getModelView(pxr, prims, time) {
+	return { prims: prims.map((prim) => {
+		const transform = localTransformForPrim(pxr, prim);
+		return {
+			path: String(prim.GetPath()),
+			parentPath: parentPathForPrim(prim),
+			name: String(prim.GetName()),
+			typeName: String(prim.GetTypeName()),
+			visibility: String(attr(prim, "visibility", time, "inherited")),
+			...transform
+		};
+	}) };
+}
+function valueAt(values, index) {
+	return index >= 0 && index < values.length ? values[index] : null;
+}
+function samplePrimvar(values, indices, interpolation, pointIndex, faceIndex, faceVertexIndex, pointCount, faceCount, faceVertexCount) {
+	if (values.length === 0) return null;
+	let domainIndex;
+	if (values.length === faceVertexCount) domainIndex = faceVertexIndex;
+	else if (values.length === pointCount) domainIndex = pointIndex;
+	else if (values.length === faceCount) domainIndex = faceIndex;
+	else if (values.length === 1) domainIndex = 0;
+	else if (interpolation === "faceVarying") domainIndex = faceVertexIndex;
+	else if (interpolation === "vertex" || interpolation === "varying") domainIndex = pointIndex;
+	else if (interpolation === "uniform") domainIndex = faceIndex;
+	else domainIndex = pointIndex;
+	let valueIndex = domainIndex;
+	if (indices.length > 0) {
+		const indexed = indices[domainIndex];
+		if (indexed === void 0) return null;
+		valueIndex = indexed;
+	}
+	return valueAt(values, valueIndex);
+}
+function meshPrimvar(prim, name, time) {
+	return {
+		values: toArray(attr(prim, name, time, [])),
+		indices: toNumberArray(attr(prim, `${name}:indices`, time, [])),
+		interpolation: String(attrMetadata(prim, name, "interpolation", attr(prim, `${name}:interpolation`, time, "")) || "") || null
+	};
+}
+function asVec2(value, fallback) {
+	const numbers = toNumberArray(value);
+	if (numbers.length < 2) return fallback;
+	return [numbers[0] ?? fallback[0], numbers[1] ?? fallback[1]];
+}
+function asFloat(value, fallback = 0) {
+	const number = asFiniteNumber(value);
+	return number === null ? fallback : number;
+}
+function shaderInputConnectionPath(shader, inputName) {
+	const attribute = shader.GetAttribute(inputName);
+	try {
+		if (!isValid$1(attribute)) return null;
+		return connectionSourcePath(attribute);
+	} finally {
+		dispose$1(attribute);
+	}
+}
+function shaderChildByPath(material, path) {
+	const children = primChildren(material);
+	try {
+		for (const child of children) if (String(child.GetPath()) === path) return child;
+		return null;
+	} finally {
+		for (const child of children) if (String(child.GetPath()) !== path) dispose$1(child);
+	}
+}
+function primvarNameForTextureShader(pxr, stage, material, textureShader, time) {
+	const stSourcePath = shaderInputConnectionPath(textureShader, "inputs:st");
+	if (!stSourcePath) return null;
+	const stSource = shaderChildByPath(material, stSourcePath) ?? primAtPath(pxr, stage, stSourcePath);
+	try {
+		if (!isValid$1(stSource)) return null;
+		const id = attr(stSource, "info:id", time);
+		if (id === "UsdPrimvarReader_float2") {
+			const varname = attr(stSource, "inputs:varname", time);
+			return typeof varname === "string" && varname ? varname : null;
+		}
+		if (id === "UsdTransform2d") {
+			const nestedSourcePath = shaderInputConnectionPath(stSource, "inputs:in") ?? shaderInputConnectionPath(stSource, "inputs:st");
+			if (!nestedSourcePath) return null;
+			const nestedSource = shaderChildByPath(material, nestedSourcePath) ?? primAtPath(pxr, stage, nestedSourcePath);
+			try {
+				if (!isValid$1(nestedSource) || attr(nestedSource, "info:id", time) !== "UsdPrimvarReader_float2") return null;
+				const varname = attr(nestedSource, "inputs:varname", time);
+				return typeof varname === "string" && varname ? varname : null;
+			} finally {
+				dispose$1(nestedSource);
+			}
+		}
+		return null;
+	} finally {
+		dispose$1(stSource);
+	}
+}
+function texturePrimvarForMaterial(pxr, stage, materialPath, time) {
+	if (!materialPath) return "primvars:st";
+	const material = primAtPath(pxr, stage, materialPath);
+	try {
+		if (!isValid$1(material)) return "primvars:st";
+		const children = primChildren(material);
+		try {
+			for (const shader of children) {
+				if (shader.GetTypeName() !== "Shader" || attr(shader, "info:id", time) !== "UsdUVTexture") continue;
+				const varname = primvarNameForTextureShader(pxr, stage, material, shader, time);
+				if (varname) return `primvars:${varname}`;
+			}
+		} finally {
+			disposeAll(children);
+		}
+		return "primvars:st";
+	} finally {
+		dispose$1(material);
+	}
+}
+function textureTransformForMaterial(pxr, stage, materialPath, time) {
+	if (!materialPath) return null;
+	const material = primAtPath(pxr, stage, materialPath);
+	try {
+		if (!isValid$1(material)) return null;
+		const children = primChildren(material);
+		try {
+			for (const shader of children) {
+				if (shader.GetTypeName() !== "Shader" || attr(shader, "info:id", time) !== "UsdUVTexture") continue;
+				const stAttribute = shader.GetAttribute("inputs:st");
+				try {
+					if (!isValid$1(stAttribute)) continue;
+					const sourcePath = connectionSourcePath(stAttribute);
+					if (!sourcePath) return null;
+					const transform = primAtPath(pxr, stage, sourcePath);
+					try {
+						if (!isValid$1(transform) || attr(transform, "info:id", time) !== "UsdTransform2d") return null;
+						const scale = asVec2(attr(transform, "inputs:scale", time), [1, 1]);
+						const translation = asVec2(attr(transform, "inputs:translation", time), [0, 0]);
+						return {
+							scaleX: scale[0],
+							scaleY: scale[1],
+							translateX: translation[0],
+							translateY: translation[1],
+							rotation: asFloat(attr(transform, "inputs:rotation", time))
+						};
+					} finally {
+						dispose$1(transform);
+					}
+				} finally {
+					dispose$1(stAttribute);
+				}
+			}
+		} finally {
+			disposeAll(children);
+		}
+		return null;
+	} finally {
+		dispose$1(material);
+	}
+}
+function transformUv(uv, transform) {
+	const numbers = toNumberArray(uv);
+	if (numbers.length < 2) return null;
+	let u = numbers[0] ?? 0;
+	let v = numbers[1] ?? 0;
+	if (!transform) return [u, v];
+	u *= transform.scaleX;
+	v *= transform.scaleY;
+	const rotation = transform.rotation * Math.PI / 180;
+	if (rotation !== 0) {
+		const cos = Math.cos(rotation);
+		const sin = Math.sin(rotation);
+		const nextU = u * cos - v * sin;
+		const nextV = u * sin + v * cos;
+		u = nextU;
+		v = nextV;
+	}
+	return [u + transform.translateX, v + transform.translateY];
+}
+function triangulateMesh(pxr, stage, prim, time) {
+	const points = toArray(attr(prim, "points", time, []));
+	const faceCounts = toNumberArray(attr(prim, "faceVertexCounts", time, []));
+	const faceIndices = toNumberArray(attr(prim, "faceVertexIndices", time, []));
+	const normals = toArray(attr(prim, "normals", time, []));
+	const normalInterpolation = String(attrMetadata(prim, "normals", "interpolation", attr(prim, "normals:interpolation", time, "")) || "") || null;
+	const boundMaterial = materialBinding(prim);
+	const uv = meshPrimvar(prim, texturePrimvarForMaterial(pxr, stage, boundMaterial, time), time);
+	const colors = toArray(attr(prim, "primvars:displayColor", time, []));
+	const opacities = toArray(attr(prim, "primvars:displayOpacity", time, []));
+	const uvTransform = textureTransformForMaterial(pxr, stage, boundMaterial, time);
+	const triangleCorners = [];
+	let cursor = 0;
+	for (let faceIndex = 0; faceIndex < faceCounts.length; ++faceIndex) {
+		const count = faceCounts[faceIndex] ?? 0;
+		const face = faceIndices.slice(cursor, cursor + count);
+		for (let index = 1; index < count - 1; ++index) triangleCorners.push([
+			face[0] ?? -1,
+			faceIndex,
+			cursor
+		], [
+			face[index] ?? -1,
+			faceIndex,
+			cursor + index
+		], [
+			face[index + 1] ?? -1,
+			faceIndex,
+			cursor + index + 1
+		]);
+		cursor += count;
+	}
+	const positions = [];
+	const flatNormals = [];
+	const uvs = [];
+	for (const [pointIndex, faceIndex, faceVertexIndex] of triangleCorners) {
+		const point = toNumberArray(points[pointIndex]);
+		if (point.length >= 3) positions.push(point[0] ?? 0, point[1] ?? 0, point[2] ?? 0);
+		if (normals.length > 0) {
+			const normal = toNumberArray(samplePrimvar(normals, [], normalInterpolation, pointIndex, faceIndex, faceVertexIndex, points.length, faceCounts.length, faceIndices.length));
+			if (normal.length >= 3) flatNormals.push(normal[0] ?? 0, normal[1] ?? 0, normal[2] ?? 0);
+		}
+		if (uv.values.length > 0) {
+			const transformedUv = transformUv(samplePrimvar(uv.values, uv.indices, uv.interpolation, pointIndex, faceIndex, faceVertexIndex, points.length, faceCounts.length, faceIndices.length), uvTransform);
+			if (transformedUv) uvs.push(transformedUv[0], transformedUv[1]);
+		}
+	}
+	return {
+		positions,
+		normals: flatNormals,
+		uvs,
+		displayColor: colors.length > 0 ? toVector3(colors[0], [
+			1,
+			1,
+			1
+		]) : null,
+		displayOpacity: opacities.length > 0 ? asFiniteNumber(opacities[0]) : null
+	};
+}
+function getModelElements(pxr, stage, prims, time) {
+	const elements = [];
+	for (const prim of prims) {
+		if (prim.GetTypeName() !== "Mesh") continue;
+		elements.push({
+			path: String(prim.GetPath()),
+			doubleSided: Boolean(attr(prim, "doubleSided", time, false)),
+			material: materialBinding(prim),
+			geometry: triangulateMesh(pxr, stage, prim, time)
+		});
+	}
+	return elements;
+}
+function collectShaderInputs(prim, time) {
+	const inputs = {};
+	const attributes = prim.GetAttributes();
+	try {
+		for (const attribute of attributes) {
+			const name = String(attribute.GetName());
+			if (!name.includes("inputs:")) continue;
+			if (!MATERIAL_INPUT_SUFFIXES.some((suffix) => name.endsWith(suffix))) continue;
+			const value = attribute.Get(time);
+			const connections = attribute.GetConnections();
+			if (value !== null && value !== void 0) inputs[name] = normalizeValue(value);
+			if (Array.isArray(connections) && connections.length > 0) inputs[`${name}.connect`] = connections.map(String);
+		}
+	} finally {
+		disposeAll(attributes);
+	}
+	return inputs;
+}
+function getModelMaterials(prims, time) {
+	const materials = [];
+	for (const prim of prims) {
+		if (prim.GetTypeName() !== "Material") continue;
+		const children = primChildren(prim);
+		const shaders = [];
+		try {
+			for (const child of children) {
+				if (child.GetTypeName() !== "Shader") continue;
+				const idValue = attr(child, "info:id", time);
+				const id = typeof idValue === "string" ? idValue : null;
+				const inputs = collectShaderInputs(child, time);
+				if (Object.keys(inputs).length === 0 && id !== "UsdPreviewSurface" && id !== "UsdUVTexture") continue;
+				shaders.push({
+					path: String(child.GetPath()),
+					id,
+					inputs
+				});
+			}
+		} finally {
+			disposeAll(children);
+		}
+		materials.push({
+			path: String(prim.GetPath()),
+			inputs: collectShaderInputs(prim, time),
+			shaders
+		});
+	}
+	return materials;
+}
+function driveForNamespace(prim, namespace, time) {
+	const drive = {
+		targetPosition: asFiniteNumber(attr(prim, `drive:${namespace}:physics:targetPosition`, time)),
+		targetVelocity: asFiniteNumber(attr(prim, `drive:${namespace}:physics:targetVelocity`, time)),
+		stiffness: asFiniteNumber(attr(prim, `drive:${namespace}:physics:stiffness`, time)),
+		damping: asFiniteNumber(attr(prim, `drive:${namespace}:physics:damping`, time)),
+		maxForce: asFiniteNumber(attr(prim, `drive:${namespace}:physics:maxForce`, time))
+	};
+	return Object.values(drive).some((value) => value !== null) ? drive : null;
+}
+function jointTypeForPrim(typeName) {
+	if (JOINT_TYPES[typeName]) return JOINT_TYPES[typeName];
+	if (typeName.startsWith("Physics") && typeName.endsWith("Joint")) return typeName.slice(7, -5).toLowerCase() || "joint";
+	return null;
+}
+function getModelJoints(prims, time) {
+	const joints = [];
+	for (const prim of prims) {
+		const typeName = String(prim.GetTypeName());
+		const jointType = jointTypeForPrim(typeName);
+		if (!jointType) continue;
+		const angularDrive = driveForNamespace(prim, "angular", time);
+		const linearDrive = driveForNamespace(prim, "linear", time);
+		const drives = {};
+		if (angularDrive) drives.angular = angularDrive;
+		if (linearDrive) drives.linear = linearDrive;
+		const body0 = relationshipTargets(prim, "physics:body0");
+		const body1 = relationshipTargets(prim, "physics:body1");
+		const drive = jointType === "prismatic" ? linearDrive ?? angularDrive : angularDrive ?? linearDrive;
+		joints.push({
+			path: String(prim.GetPath()),
+			name: String(prim.GetName()),
+			typeName,
+			jointType,
+			body0: body0[0] ?? null,
+			body1: body1[0] ?? null,
+			axis: typeof attr(prim, "physics:axis", time) === "string" ? String(attr(prim, "physics:axis", time)) : null,
+			localPos0: toVector3(attr(prim, "physics:localPos0", time, [
+				0,
+				0,
+				0
+			]), [
+				0,
+				0,
+				0
+			]),
+			localPos1: toVector3(attr(prim, "physics:localPos1", time, [
+				0,
+				0,
+				0
+			]), [
+				0,
+				0,
+				0
+			]),
+			localRot0: toVector4(attr(prim, "physics:localRot0", time)),
+			localRot1: toVector4(attr(prim, "physics:localRot1", time)),
+			lowerLimit: asFiniteNumber(attr(prim, "physics:lowerLimit", time)),
+			upperLimit: asFiniteNumber(attr(prim, "physics:upperLimit", time)),
+			enabled: Boolean(attr(prim, "physics:jointEnabled", time, true)),
+			drive,
+			drives
+		});
+	}
+	return joints;
+}
+function stageTimingFromLayer(rootLayer) {
+	const text = String(rootLayer.ExportToString?.() ?? "");
+	const numberFor = (name) => {
+		const match = new RegExp(`${name}\\s*=\\s*(-?\\d+(?:\\.\\d+)?)`).exec(text);
+		if (!match?.[1]) return null;
+		const value = Number(match[1]);
+		return Number.isFinite(value) ? value : null;
+	};
+	return {
+		startTimeCode: numberFor("startTimeCode"),
+		endTimeCode: numberFor("endTimeCode"),
+		timeCodesPerSecond: numberFor("timeCodesPerSecond") ?? 24
+	};
+}
+function getStageInfo(pxr, stage, options) {
+	const defaultPrim = stage.GetDefaultPrim();
+	const rootLayer = stage.GetRootLayer();
+	try {
+		const timing = stageTimingFromLayer(rootLayer);
+		return {
+			sourcePath: options.sourcePath,
+			rootLayerIdentifier: options.rootLayerIdentifier,
+			defaultPrim: isValid$1(defaultPrim) ? String(defaultPrim.GetPath()) : null,
+			upAxis: String(pxr.UsdGeom.GetStageUpAxis(stage)),
+			...timing
+		};
+	} finally {
+		dispose$1(rootLayer);
+		dispose$1(defaultPrim);
+	}
+}
+function localMatrixFromXformOps(prim, time) {
+	const opOrder = toArray(attr(prim, "xformOpOrder", time, [])).map(String);
+	if (opOrder.length === 0) return null;
+	let matrix = identityMatrix();
+	let foundOp = false;
+	for (const opName of opOrder) {
+		if (opName.startsWith("!")) {
+			matrix = identityMatrix();
+			continue;
+		}
+		const opMatrix = matrixFromXformOp(opName, attr(prim, opName, time));
+		if (!opMatrix) continue;
+		matrix = multiplyMatrices(matrix, opMatrix);
+		foundOp = true;
+	}
+	return foundOp ? matrix : null;
+}
+function sampleLocalMatrix(pxr, prim, frame) {
+	const time = new pxr.Usd.TimeCode(frame);
+	try {
+		return localMatrixFromXformOps(prim, time);
+	} finally {
+		dispose$1(time);
+	}
+}
+function animationSampleFrames(start, end) {
+	const maxSamples = 1e3;
+	const span = end - start;
+	if (span <= 0) return [];
+	const wholeFrameCount = Number.isInteger(start) && Number.isInteger(end) ? Math.floor(span) + 1 : 0;
+	if (wholeFrameCount > 1 && wholeFrameCount <= maxSamples) return Array.from({ length: wholeFrameCount }, (_, index) => start + index);
+	const sampleCount = Math.min(maxSamples, Math.max(2, Math.ceil(span) + 1));
+	return Array.from({ length: sampleCount }, (_, index) => {
+		return start + span * index / (sampleCount - 1);
+	});
+}
+function getModelAnimations(pxr, prims, stageInfo) {
+	const start = stageInfo.startTimeCode ?? null;
+	const end = stageInfo.endTimeCode ?? null;
+	const timeCodesPerSecond = stageInfo.timeCodesPerSecond ?? 24;
+	if (start === null || end === null || end <= start) return [];
+	const frames = animationSampleFrames(start, end);
+	if (frames.length < 2) return [];
+	const transforms = [];
+	for (const prim of prims) {
+		if (!prim.IsA("Xformable")) continue;
+		const defaultTime = pxr.Usd.TimeCode.Default();
+		try {
+			if (toArray(attr(prim, "xformOpOrder", defaultTime, [])).length === 0) continue;
+		} finally {
+			dispose$1(defaultTime);
+		}
+		const samples = frames.map((frame) => {
+			const localMatrix = sampleLocalMatrix(pxr, prim, frame);
+			return localMatrix ? {
+				time: (frame - start) / timeCodesPerSecond,
+				localMatrix
+			} : null;
+		}).filter((sample) => sample !== null);
+		if (samples.length < 2) continue;
+		const first = samples[0]?.localMatrix ?? null;
+		if (!samples.some((sample) => !matricesNearlyEqual(first, sample.localMatrix))) continue;
+		transforms.push({
+			primPath: String(prim.GetPath()),
+			samples
+		});
+	}
+	return transforms.length > 0 ? [{
+		startTimeCode: start,
+		endTimeCode: end,
+		timeCodesPerSecond,
+		transforms
+	}] : [];
+}
+function extractUSDModelData(pxr, stage, options = {}) {
+	const resolvedOptions = {
+		sourcePath: options.sourcePath ?? "",
+		rootLayerIdentifier: options.rootLayerIdentifier ?? ""
+	};
+	const time = pxr.Usd.TimeCode.Default();
+	const prims = stage.Traverse();
+	try {
+		const stageInfo = getStageInfo(pxr, stage, resolvedOptions);
+		return {
+			stage: stageInfo,
+			view: getModelView(pxr, prims, time),
+			elements: getModelElements(pxr, stage, prims, time),
+			materials: getModelMaterials(prims, time),
+			joints: getModelJoints(prims, time),
+			animations: getModelAnimations(pxr, prims, stageInfo)
+		};
+	} finally {
+		disposeAll(prims);
+		dispose$1(time);
+	}
+}
+//#endregion
+//#region src/three.ts
+const sharedTextureCache = /* @__PURE__ */ new Map();
+function matrixFromUsd(values) {
+	const matrix = new THREE.Matrix4();
+	matrix.set(values[0] ?? 1, values[4] ?? 0, values[8] ?? 0, values[12] ?? 0, values[1] ?? 0, values[5] ?? 1, values[9] ?? 0, values[13] ?? 0, values[2] ?? 0, values[6] ?? 0, values[10] ?? 1, values[14] ?? 0, values[3] ?? 0, values[7] ?? 0, values[11] ?? 0, values[15] ?? 1);
+	return matrix;
+}
+function applyLocalMatrix(object, values) {
+	if (!values || values.length < 16) return;
+	matrixFromUsd(values).decompose(object.position, object.quaternion, object.scale);
+}
+function vectorColor(value) {
+	if (!Array.isArray(value) || value.length < 3) return null;
+	const r = Number(value[0]);
+	const g = Number(value[1]);
+	const b = Number(value[2]);
+	if (![
+		r,
+		g,
+		b
+	].every(Number.isFinite)) return null;
+	return new THREE.Color(r, g, b);
+}
+function firstInput(material, suffixes) {
+	if (!material) return null;
+	const inputSources = [material.inputs, ...material.shaders.map((shader) => shader.inputs)];
+	for (const inputs of inputSources) for (const [key, value] of Object.entries(inputs)) if (suffixes.some((suffix) => key.endsWith(suffix))) return value;
+	return null;
+}
+function publicUrlFromAsset(asset, options, material, shader) {
+	if (!asset || typeof asset !== "object") return null;
+	const assetValue = asset;
+	const resolved = options.textureResolver?.(assetValue, {
+		sourcePath: options.sourcePath ?? "",
+		material,
+		shader
+	});
+	if (resolved) return resolved;
+	if (assetValue.url && looksLikeTextureURL(assetValue.url)) return assetValue.url;
+	if (assetValue.path) {
+		if (!looksLikeTextureURL(assetValue.path)) return null;
+		try {
+			return new URL(assetValue.path, options.sourcePath || globalThis.location?.href).href;
+		} catch {
+			return assetValue.path;
+		}
+	}
+	return null;
+}
+function looksLikeTextureURL(value) {
+	if (/^(blob|data):/i.test(value)) return true;
+	return /\.(png|jpe?g|webp)(?:[?#].*)?$/i.test(value);
+}
+function textureWrap(value) {
+	if (value === "repeat") return THREE.RepeatWrapping;
+	if (value === "mirror") return THREE.MirroredRepeatWrapping;
+	return THREE.ClampToEdgeWrapping;
+}
+function shaderPathFromConnection(value) {
+	return Array.isArray(value) && typeof value[0] === "string" ? value[0].split(".outputs:")[0] ?? null : null;
+}
+function findTexture(material, options, connectionSuffixes, fallbackToAnyTexture = false) {
+	if (!material) return null;
+	const connectedPath = shaderPathFromConnection(firstInput(material, connectionSuffixes));
+	const textureShader = material.shaders.find((shader) => shader.id === "UsdUVTexture" && (!connectedPath || shader.path === connectedPath)) ?? (fallbackToAnyTexture ? material.shaders.find((shader) => shader.id === "UsdUVTexture") : null);
+	if (!textureShader) return null;
+	const url = publicUrlFromAsset(textureShader.inputs["inputs:file"], options, material, textureShader);
+	if (!url) return null;
+	return {
+		url,
+		wrapS: textureWrap(textureShader.inputs["inputs:wrapS"]),
+		wrapT: textureWrap(textureShader.inputs["inputs:wrapT"])
+	};
+}
+function loadTexture(url, options, colorSpace) {
+	const cache = options.textureCache ?? sharedTextureCache;
+	const cacheKey = `${colorSpace}:${url}`;
+	const cached = cache.get(cacheKey);
+	if (cached) return cached;
+	const texture = (options.textureLoader ?? new THREE.TextureLoader()).load(url);
+	texture.colorSpace = colorSpace;
+	texture.flipY = true;
+	cache.set(cacheKey, texture);
+	return texture;
+}
+function applyTextureWrap(texture, info) {
+	texture.wrapS = info.wrapS;
+	texture.wrapT = info.wrapT;
+}
+function buildMaterial(material, element, options) {
+	const displayColor = element.geometry.displayColor ? new THREE.Color(...element.geometry.displayColor) : null;
+	const baseColor = vectorColor(firstInput(material, [
+		"diffuseColor",
+		"base_color",
+		"baseColor"
+	])) ?? displayColor ?? new THREE.Color(13158600);
+	const opacityInput = firstInput(material, ["opacity", "alpha"]);
+	const opacity = typeof opacityInput === "number" ? opacityInput : element.geometry.displayOpacity ?? 1;
+	const roughness = firstInput(material, ["roughness"]);
+	const metallic = firstInput(material, ["metallic", "metallicFactor"]);
+	const diffuseTexture = options.loadTextures === false ? null : findTexture(material, options, ["diffuseColor.connect", "baseColor.connect"], true);
+	const normalTexture = options.loadTextures === false ? null : findTexture(material, options, ["normal.connect"]);
+	const metallicTexture = options.loadTextures === false ? null : findTexture(material, options, ["metallic.connect", "metallicFactor.connect"]);
+	const roughnessTexture = options.loadTextures === false ? null : findTexture(material, options, ["roughness.connect"]);
+	const map = diffuseTexture ? loadTexture(diffuseTexture.url, options, THREE.SRGBColorSpace) : null;
+	const normalMap = normalTexture ? loadTexture(normalTexture.url, options, THREE.NoColorSpace) : null;
+	const metalnessMap = metallicTexture ? loadTexture(metallicTexture.url, options, THREE.NoColorSpace) : null;
+	const roughnessMap = roughnessTexture ? loadTexture(roughnessTexture.url, options, THREE.NoColorSpace) : null;
+	if (map && diffuseTexture) applyTextureWrap(map, diffuseTexture);
+	if (normalMap && normalTexture) applyTextureWrap(normalMap, normalTexture);
+	if (metalnessMap && metallicTexture) applyTextureWrap(metalnessMap, metallicTexture);
+	if (roughnessMap && roughnessTexture) applyTextureWrap(roughnessMap, roughnessTexture);
+	return new THREE.MeshStandardMaterial({
+		color: baseColor,
+		map,
+		normalMap,
+		metalnessMap,
+		roughnessMap,
+		roughness: typeof roughness === "number" ? roughness : .55,
+		metalness: typeof metallic === "number" ? metallic : 0,
+		opacity,
+		transparent: opacity < 1,
+		side: element.doubleSided ? THREE.DoubleSide : THREE.FrontSide
+	});
+}
+function buildGeometry(element) {
+	const geometry = new THREE.BufferGeometry();
+	geometry.setAttribute("position", new THREE.Float32BufferAttribute(element.geometry.positions, 3));
+	if (element.geometry.normals.length > 0 && element.geometry.normals.length === element.geometry.positions.length) geometry.setAttribute("normal", new THREE.Float32BufferAttribute(element.geometry.normals, 3));
+	else geometry.computeVertexNormals();
+	if (element.geometry.uvs.length > 0) geometry.setAttribute("uv", new THREE.Float32BufferAttribute(element.geometry.uvs, 2));
+	geometry.computeBoundingBox();
+	geometry.computeBoundingSphere();
+	return geometry;
+}
+function makeObjectForPrim(primPath, elementsByPath, materialsByPath, data, options) {
+	const viewPrim = data.view.prims.find((item) => item.path === primPath);
+	const element = elementsByPath.get(primPath);
+	const object = element ? new THREE.Mesh(buildGeometry(element), buildMaterial(element.material ? materialsByPath.get(element.material) : void 0, element, options)) : new THREE.Group();
+	object.name = viewPrim?.name ?? primPath.split("/").pop() ?? primPath;
+	object.visible = viewPrim?.visibility !== "invisible";
+	object.userData.usdPath = primPath;
+	object.userData.usdTypeName = viewPrim?.typeName ?? "";
+	applyLocalMatrix(object, viewPrim?.localMatrix ?? null);
+	return object;
+}
+function attachJointUserData(data, objectsByPath) {
+	for (const joint of data.joints) {
+		const jointObject = objectsByPath.get(joint.path);
+		if (jointObject) jointObject.userData.usdJoint = joint;
+		for (const bodyPath of [joint.body0, joint.body1]) {
+			if (!bodyPath) continue;
+			const bodyObject = objectsByPath.get(bodyPath);
+			if (!bodyObject) continue;
+			const joints = bodyObject.userData.usdJoints;
+			if (Array.isArray(joints)) joints.push(joint);
+			else bodyObject.userData.usdJoints = [joint];
+		}
+	}
+}
+function createTransformTracks(animation, objectsByPath) {
+	const tracks = [];
+	for (const transform of animation.transforms) {
+		const object = objectsByPath.get(transform.primPath);
+		if (!object || transform.samples.length < 2) continue;
+		const times = [];
+		const positions = [];
+		const quaternions = [];
+		const scales = [];
+		let previousQuaternion = null;
+		for (const sample of transform.samples) {
+			const matrix = matrixFromUsd(sample.localMatrix);
+			const position = new THREE.Vector3();
+			const quaternion = new THREE.Quaternion();
+			const scale = new THREE.Vector3();
+			matrix.decompose(position, quaternion, scale);
+			if (previousQuaternion && previousQuaternion.dot(quaternion) < 0) quaternion.set(-quaternion.x, -quaternion.y, -quaternion.z, -quaternion.w);
+			previousQuaternion = quaternion.clone();
+			times.push(sample.time);
+			positions.push(position.x, position.y, position.z);
+			quaternions.push(quaternion.x, quaternion.y, quaternion.z, quaternion.w);
+			scales.push(scale.x, scale.y, scale.z);
+		}
+		tracks.push(new THREE.VectorKeyframeTrack(`${object.uuid}.position`, times, positions), new THREE.QuaternionKeyframeTrack(`${object.uuid}.quaternion`, times, quaternions), new THREE.VectorKeyframeTrack(`${object.uuid}.scale`, times, scales));
+	}
+	return tracks;
+}
+function createAnimationClips(animations, objectsByPath) {
+	return animations.map((animation, index) => {
+		const tracks = createTransformTracks(animation, objectsByPath);
+		if (tracks.length === 0) return null;
+		return new THREE.AnimationClip(`USDAnimation_${index + 1}`, -1, tracks);
+	}).filter((clip) => clip !== null);
+}
+function buildUSDObject(data, options = {}) {
+	const sourcePath = options.sourcePath ?? data.stage.sourcePath;
+	const wrapper = new THREE.Group();
+	wrapper.name = `USD:${sourcePath}`;
+	wrapper.userData.usdMetadata = data;
+	wrapper.userData.usdJoints = data.joints;
+	wrapper.userData.usdPath = data.stage.defaultPrim ?? "/";
+	wrapper.userData.usdSource = sourcePath;
+	const elementsByPath = new Map(data.elements.map((element) => [element.path, element]));
+	const materialsByPath = new Map(data.materials.map((material) => [material.path, material]));
+	const objectsByPath = /* @__PURE__ */ new Map();
+	for (const prim of data.view.prims) objectsByPath.set(prim.path, makeObjectForPrim(prim.path, elementsByPath, materialsByPath, data, {
+		...options,
+		sourcePath
+	}));
+	for (const prim of data.view.prims) {
+		const object = objectsByPath.get(prim.path);
+		if (!object) continue;
+		const parent = prim.parentPath ? objectsByPath.get(prim.parentPath) : null;
+		if (parent) parent.add(object);
+		else wrapper.add(object);
+	}
+	if (options.convertZUp !== false && data.stage.upAxis === "Z") wrapper.rotation.x = -Math.PI / 2;
+	attachJointUserData(data, objectsByPath);
+	wrapper.userData.usdObjectsByPath = objectsByPath;
+	wrapper.userData.usdAnimations = data.animations;
+	wrapper.animations = createAnimationClips(data.animations, objectsByPath);
+	return wrapper;
+}
+function createUSDLoadedModel(data, pxr, rootLayerIdentifier, options = {}, stage) {
+	const sourcePath = options.sourcePath ?? data.stage.sourcePath;
+	return {
+		scene: buildUSDObject(data, {
+			...options,
+			sourcePath
+		}),
+		metadata: data,
+		stage,
+		pxr,
+		sourcePath,
+		rootLayerIdentifier
+	};
+}
+//#endregion
+//#region src/loader.ts
+const DEFAULT_WORKING_DIRECTORY = "/tmp/openusd-three-loader";
+let nextLoadId = 0;
+function isLoadingManager(value) {
+	return !!value && typeof value === "object" && "itemStart" in value && "itemEnd" in value;
+}
+function dispose(value) {
+	if (value && typeof value === "object" && "delete" in value && typeof value.delete === "function") value.delete();
+}
+function isValid(value) {
+	return Boolean(value && (typeof value.IsValid !== "function" || value.IsValid()));
+}
+function isBlobLike(value) {
+	return typeof Blob !== "undefined" && value instanceof Blob;
+}
+function extensionForPath(path) {
+	const withoutQuery = path.split(/[?#]/)[0] ?? path;
+	const extension = /\.([a-z0-9]+)$/i.exec(withoutQuery)?.[1]?.toLowerCase();
+	if (extension === "usd" || extension === "usda" || extension === "usdc" || extension === "usdz") return extension;
+	return "usda";
+}
+function fileNameForSource(sourcePath, fallbackExtension) {
+	const name = (sourcePath.split(/[?#]/)[0] ?? sourcePath).split("/").filter(Boolean).pop();
+	if (name && /\.[a-z0-9]+$/i.test(name)) return sanitizeFileName(name);
+	return `scene.${fallbackExtension}`;
+}
+function sanitizeFileName(name) {
+	return name.replace(/[^A-Za-z0-9._-]+/g, "_").replace(/^_+/, "") || "scene.usda";
+}
+function joinFsPath(base, name) {
+	return `${base.replace(/\/+$/, "")}/${name.replace(/^\/+/, "")}`;
+}
+function normalizeBytes(input) {
+	if (input instanceof ArrayBuffer) return new Uint8Array(input);
+	return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+}
+async function sourceToWritableData(input) {
+	if (typeof input === "string") return input;
+	if (isBlobLike(input)) return new Uint8Array(await input.arrayBuffer());
+	return normalizeBytes(input);
+}
+function maybeResolveURL(path, basePath) {
+	if (!basePath) return path;
+	try {
+		return new URL(path, basePath).href;
+	} catch {
+		return `${basePath.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
+	}
+}
+function composeTextureResolver(userResolver, packageResolver) {
+	if (!packageResolver) return userResolver;
+	return (asset, context) => userResolver?.(asset, context) ?? packageResolver(asset, context);
+}
+function deleteFileIfExists(pxr, path) {
+	try {
+		if (pxr.FS.exists(path)) pxr.FS.deleteFile(path);
+	} catch {}
+}
+async function writeUSDInput(pxr, input, options) {
+	const directory = joinFsPath(options.workingDirectory, String(++nextLoadId));
+	pxr.FS.createDir(directory);
+	for (const [relativePath, file] of Object.entries(options.files ?? {})) {
+		const filePath = joinFsPath(directory, relativePath);
+		pxr.FS.writeFile(filePath, await sourceToWritableData(file));
+	}
+	const path = joinFsPath(directory, sanitizeFileName(options.fileName));
+	pxr.FS.writeFile(path, input);
+	return path;
+}
+function openStage(pxr, filePath, extension, usdzLayer) {
+	const identifiers = extension === "usdz" && usdzLayer ? [`${filePath}[${usdzLayer}]`, filePath] : [filePath];
+	for (const identifier of identifiers) {
+		const stage = pxr.Usd.Stage.Open(identifier);
+		if (isValid(stage)) return {
+			stage,
+			identifier
+		};
+		dispose(stage);
+	}
+	throw new Error(`Failed to open USD stage from ${filePath}`);
+}
+function mergeParseOptions(loaderOptions, parseOptions) {
+	const sourcePath = parseOptions.sourcePath ?? parseOptions.fileName ?? "scene.usda";
+	const extension = extensionForPath(parseOptions.fileName ?? sourcePath);
+	return {
+		...loaderOptions,
+		...parseOptions,
+		sourcePath,
+		workingDirectory: parseOptions.workingDirectory ?? loaderOptions.workingDirectory ?? DEFAULT_WORKING_DIRECTORY,
+		fileName: parseOptions.fileName ?? fileNameForSource(sourcePath, extension),
+		usdzLayer: parseOptions.usdzLayer ?? loaderOptions.usdzLayer,
+		preserveStage: parseOptions.preserveStage ?? loaderOptions.preserveStage,
+		cleanupAfterParse: parseOptions.cleanupAfterParse ?? loaderOptions.cleanupAfterParse ?? false
+	};
+}
+var USDLoader = class extends Loader {
+	options;
+	pxrPromise;
+	constructor(optionsOrManager, manager) {
+		if (isLoadingManager(optionsOrManager)) {
+			super(optionsOrManager);
+			this.options = {};
+		} else {
+			super(manager);
+			this.options = optionsOrManager ?? {};
+		}
+		this.pxrPromise = this.options.pxr ? Promise.resolve(this.options.pxr) : null;
+	}
+	setPxr(pxr) {
+		this.pxrPromise = Promise.resolve(pxr);
+		return this;
+	}
+	setUSDZLayer(layer) {
+		this.options.usdzLayer = layer;
+		return this;
+	}
+	setWorkingDirectory(path) {
+		this.options.workingDirectory = path;
+		return this;
+	}
+	load(url, onLoad, onProgress, onError) {
+		const loader = new FileLoader(this.manager);
+		loader.setPath(this.path);
+		loader.setResponseType("arraybuffer");
+		loader.setRequestHeader(this.requestHeader);
+		loader.setWithCredentials(this.withCredentials);
+		loader.load(url, (data) => {
+			const sourcePath = maybeResolveURL(url, this.path);
+			this.parseAsync(data, { sourcePath }).then(onLoad).catch((error) => {
+				if (onError) onError(error);
+				else console.error(error);
+				this.manager.itemError(url);
+			});
+		}, onProgress, onError);
+	}
+	parse(input, onLoad, onError, options = {}) {
+		this.parseAsync(input, options).then(onLoad).catch((error) => {
+			if (onError) onError(error);
+			else console.error(error);
+		});
+	}
+	async parseAsync(input, options = {}) {
+		const pxr = await this.getPxr();
+		const mergedOptions = mergeParseOptions(this.options, options);
+		const extension = extensionForPath(mergedOptions.fileName);
+		const writableData = await sourceToWritableData(input);
+		const packageTextureResolver = extension === "usdz" && writableData instanceof Uint8Array ? createPackageTextureResolver(writableData) : null;
+		let autoFiles = writableData instanceof Uint8Array && extension !== "usdz" ? await autoResolveAssetFiles(writableData, mergedOptions) : {};
+		const filePath = await writeUSDInput(pxr, writableData, {
+			...mergedOptions,
+			files: {
+				...autoFiles,
+				...mergedOptions.files
+			}
+		});
+		const { stage, identifier } = openStage(pxr, filePath, extension, mergedOptions.usdzLayer);
+		try {
+			const metadata = extractUSDModelData(pxr, stage, {
+				sourcePath: mergedOptions.sourcePath,
+				rootLayerIdentifier: identifier
+			});
+			if (extension !== "usdz") autoFiles = {
+				...autoFiles,
+				...await autoResolveTextureFiles(metadata, autoFiles, mergedOptions)
+			};
+			const autoTextureResolver = createTextureResolverFromEntries(new Map(Object.entries(autoFiles).map(([path, data]) => [path, normalizeBytes(data)])));
+			const model = createUSDLoadedModel(metadata, pxr, identifier, {
+				...mergedOptions,
+				textureResolver: composeTextureResolver(composeTextureResolver(mergedOptions.textureResolver, packageTextureResolver?.resolve), autoTextureResolver?.resolve)
+			}, mergedOptions.preserveStage ? stage : void 0);
+			if (packageTextureResolver) model.scene.userData.usdzTextureURLs = packageTextureResolver.urls;
+			if (autoTextureResolver) model.scene.userData.autoTextureURLs = autoTextureResolver.urls;
+			return model;
+		} finally {
+			if (!mergedOptions.preserveStage) dispose(stage);
+			if (mergedOptions.cleanupAfterParse && !mergedOptions.preserveStage) deleteFileIfExists(pxr, filePath);
+		}
+	}
+	async getPxr() {
+		if (!this.pxrPromise) {
+			if (!this.options.pxrOptions) throw new Error("USDLoader requires either a pxr instance or pxrOptions");
+			this.pxrPromise = createPxr(this.options.pxrOptions);
+		}
+		return this.pxrPromise;
+	}
+};
+//#endregion
+//#region src/manipulation-controls.ts
+const axisVectors = {
+	X: new THREE.Vector3(1, 0, 0),
+	Y: new THREE.Vector3(0, 1, 0),
+	Z: new THREE.Vector3(0, 0, 1)
+};
+function clamp(value, min, max) {
+	return Math.min(max, Math.max(min, value));
+}
+function limitsForJoint(joint) {
+	if (joint.lowerLimit !== null && joint.upperLimit !== null) return {
+		lower: joint.lowerLimit,
+		upper: joint.upperLimit
+	};
+	return joint.jointType === "revolute" ? {
+		lower: -180,
+		upper: 180
+	} : {
+		lower: -1,
+		upper: 1
+	};
+}
+function initialValueForJoint(joint) {
+	const { lower, upper } = limitsForJoint(joint);
+	return clamp(joint.drive?.targetPosition ?? lower, lower, upper);
+}
+function isManipulableJoint(joint) {
+	return joint.enabled && (joint.jointType === "revolute" || joint.jointType === "prismatic");
+}
+function objectsByPathForRoot(root) {
+	const userDataMap = root.userData.usdObjectsByPath;
+	if (userDataMap instanceof Map) return new Map([...userDataMap.entries()].filter((entry) => {
+		return typeof entry[0] === "string" && entry[1] instanceof THREE.Object3D;
+	}));
+	const objectsByPath = /* @__PURE__ */ new Map();
+	root.traverse((child) => {
+		const usdPath = child.userData.usdPath;
+		if (typeof usdPath === "string") objectsByPath.set(usdPath, child);
+	});
+	return objectsByPath;
+}
+function findUSDModels(scene) {
+	const models = [];
+	scene.traverse((object) => {
+		const metadata = object.userData.usdMetadata;
+		if (!metadata) return;
+		object.updateMatrixWorld(true);
+		models.push({
+			root: object,
+			metadata,
+			objectsByPath: objectsByPathForRoot(object)
+		});
+	});
+	return models;
+}
+function modelStateSignature(models) {
+	return models.map((model) => {
+		const matrix = model.root.matrixWorld.elements.map((value) => value.toFixed(5)).join(",");
+		const stage = model.metadata.stage;
+		return [
+			model.root.uuid,
+			stage.rootLayerIdentifier,
+			stage.defaultPrim ?? "",
+			model.metadata.joints.length,
+			matrix
+		].join(":");
+	}).join("|");
+}
+function jointForObject(models, object) {
+	for (const model of models) for (const joint of model.metadata.joints) {
+		if (!isManipulableJoint(joint) || !joint.body1) continue;
+		const bodyObject = model.objectsByPath.get(joint.body1);
+		if (!bodyObject) continue;
+		let current = object;
+		while (current) {
+			if (current === bodyObject) return {
+				model,
+				joint,
+				object: bodyObject,
+				body0: joint.body0 ? model.objectsByPath.get(joint.body0) ?? null : null
+			};
+			current = current.parent;
+		}
+	}
+	return null;
+}
+function jointValueKey(model, joint) {
+	return `${model.root.uuid}:${joint.path}`;
+}
+function localAxisForJoint(joint) {
+	return axisVectors[joint.axis ?? ""]?.clone() ?? axisVectors.X.clone();
+}
+function localPivotForJoint(joint) {
+	return new THREE.Vector3(joint.localPos0[0] ?? 0, joint.localPos0[1] ?? 0, joint.localPos0[2] ?? 0);
+}
+function parentLocalPoint(object, body0, point) {
+	if (!body0) return point.clone();
+	const worldPoint = body0.localToWorld(point.clone());
+	return object.parent ? object.parent.worldToLocal(worldPoint) : worldPoint;
+}
+function parentLocalVectorForJoint(joint, object, body0, delta) {
+	const pivot = localPivotForJoint(joint);
+	const start = parentLocalPoint(object, body0, pivot);
+	return parentLocalPoint(object, body0, pivot.clone().add(localAxisForJoint(joint).multiplyScalar(delta))).sub(start);
+}
+function parentLocalAxisForJoint(joint, object, body0) {
+	const axis = parentLocalVectorForJoint(joint, object, body0, 1);
+	if (axis.lengthSq() < 1e-10) return localAxisForJoint(joint).normalize();
+	return axis.normalize();
+}
+function parentLocalPivotForJoint(joint, object, body0) {
+	return parentLocalPoint(object, body0, localPivotForJoint(joint));
+}
+function parentLocalToWorld(object, point) {
+	return object.parent ? object.parent.localToWorld(point.clone()) : point.clone();
+}
+function projectToClient(point, camera, rect) {
+	const ndc = point.clone().project(camera);
+	return new THREE.Vector2((ndc.x * .5 + .5) * rect.width, (-ndc.y * .5 + .5) * rect.height);
+}
+function prismaticDragMapping(joint, object, body0, camera, rect) {
+	const { lower, upper } = limitsForJoint(joint);
+	const referenceDelta = Math.max(Math.abs(upper - lower), .1);
+	const startPivot = parentLocalPivotForJoint(joint, object, body0);
+	const start = parentLocalToWorld(object, startPivot);
+	const screenVector = projectToClient(parentLocalToWorld(object, startPivot.clone().add(parentLocalVectorForJoint(joint, object, body0, referenceDelta))), camera, rect).sub(projectToClient(start, camera, rect));
+	const screenLength = screenVector.length();
+	if (screenLength < 1) return {
+		screenAxis: new THREE.Vector2(1, 0),
+		valuePerPixel: referenceDelta / 180
+	};
+	return {
+		screenAxis: screenVector.normalize(),
+		valuePerPixel: referenceDelta / screenLength
+	};
+}
+function fallbackRevoluteScreenAxis(pivot, axis, camera, rect) {
+	const projectedAxis = projectToClient(pivot.clone().add(axis), camera, rect).sub(projectToClient(pivot, camera, rect));
+	if (projectedAxis.length() < 1) return new THREE.Vector2(1, -1).normalize();
+	return new THREE.Vector2(-projectedAxis.y, projectedAxis.x).normalize();
+}
+function revoluteDragMapping(joint, object, body0, camera, rect) {
+	const axis = parentLocalAxisForJoint(joint, object, body0);
+	const pivot = parentLocalPivotForJoint(joint, object, body0);
+	const referenceDegrees = 12;
+	const referenceRadians = THREE.MathUtils.degToRad(referenceDegrees);
+	const bounds = new THREE.Box3().setFromObject(object);
+	const center = object.parent ? object.parent.worldToLocal(bounds.getCenter(new THREE.Vector3())) : bounds.getCenter(new THREE.Vector3());
+	const size = bounds.getSize(new THREE.Vector3());
+	const radius = Math.max(size.length() * .25, .05);
+	const radiusVector = center.sub(pivot);
+	radiusVector.addScaledVector(axis, -radiusVector.dot(axis));
+	if (radiusVector.lengthSq() < 1e-8) {
+		const fallback = Math.abs(axis.dot(new THREE.Vector3(0, 1, 0))) > .9 ? new THREE.Vector3(1, 0, 0) : new THREE.Vector3(0, 1, 0);
+		radiusVector.copy(fallback.cross(axis));
+	}
+	radiusVector.setLength(Math.max(radiusVector.length(), radius));
+	const start = pivot.clone().add(radiusVector);
+	const end = pivot.clone().add(radiusVector.clone().applyAxisAngle(axis, referenceRadians));
+	const startWorld = parentLocalToWorld(object, start);
+	const screenVector = projectToClient(parentLocalToWorld(object, end), camera, rect).sub(projectToClient(startWorld, camera, rect));
+	const screenLength = screenVector.length();
+	if (screenLength < 1) return {
+		screenAxis: fallbackRevoluteScreenAxis(parentLocalToWorld(object, pivot), parentLocalToWorld(object, pivot.clone().add(axis)).sub(parentLocalToWorld(object, pivot)), camera, rect),
+		valuePerPixel: referenceDegrees / 140
+	};
+	return {
+		screenAxis: screenVector.normalize(),
+		valuePerPixel: referenceDegrees / screenLength
+	};
+}
+function updateJointTransform(drag, value) {
+	const delta = value - drag.startValue;
+	const axis = parentLocalAxisForJoint(drag.joint, drag.object, drag.body0);
+	const nextLocal = new THREE.Matrix4();
+	if (drag.joint.jointType === "revolute") {
+		const pivot = parentLocalPivotForJoint(drag.joint, drag.object, drag.body0);
+		const rotation = new THREE.Matrix4().makeRotationAxis(axis, THREE.MathUtils.degToRad(delta));
+		nextLocal.makeTranslation(pivot.x, pivot.y, pivot.z).multiply(rotation).multiply(new THREE.Matrix4().makeTranslation(-pivot.x, -pivot.y, -pivot.z)).multiply(drag.initialLocalMatrix);
+		nextLocal.decompose(drag.object.position, drag.object.quaternion, drag.object.scale);
+		drag.object.updateMatrixWorld(true);
+		return;
+	}
+	const translation = parentLocalVectorForJoint(drag.joint, drag.object, drag.body0, delta);
+	nextLocal.makeTranslation(translation.x, translation.y, translation.z).multiply(drag.initialLocalMatrix);
+	nextLocal.decompose(drag.object.position, drag.object.quaternion, drag.object.scale);
+	drag.object.updateMatrixWorld(true);
+}
+function highlightedMaterials(material, color) {
+	const highlighted = (Array.isArray(material) ? material : [material]).map((item) => {
+		const cloned = item.clone();
+		if ("emissive" in cloned) {
+			const emissiveMaterial = cloned;
+			emissiveMaterial.emissive = color.clone();
+			emissiveMaterial.emissiveIntensity = Math.max(emissiveMaterial.emissiveIntensity, .28);
+		}
+		return cloned;
+	});
+	return Array.isArray(material) ? highlighted : highlighted[0];
+}
+function disposeMaterial(material) {
+	const materials = Array.isArray(material) ? material : [material];
+	for (const item of materials) item.dispose();
+}
+var USDManipulationControls = class {
+	raycaster = new THREE.Raycaster();
+	pointer = new THREE.Vector2();
+	jointValues = /* @__PURE__ */ new Map();
+	highlighted = /* @__PURE__ */ new Map();
+	activeDrag = null;
+	hovered = null;
+	modelStateSignature = null;
+	_enabled;
+	disposed = false;
+	scene;
+	camera;
+	domElement;
+	controls;
+	highlightColor;
+	onChange;
+	onHoverChange;
+	constructor(options) {
+		this.scene = options.scene;
+		this.camera = options.camera;
+		this.domElement = options.domElement;
+		this.controls = options.controls ?? null;
+		this.highlightColor = new THREE.Color(options.highlightColor ?? 16777215);
+		this._enabled = options.enabled ?? true;
+		this.onChange = options.onChange;
+		this.onHoverChange = options.onHoverChange;
+		this.domElement.addEventListener("pointermove", this.onPointerMove);
+		this.domElement.addEventListener("pointerdown", this.onPointerDown);
+		this.domElement.addEventListener("pointerup", this.onPointerUp);
+		this.domElement.addEventListener("pointercancel", this.onPointerUp);
+	}
+	get enabled() {
+		return this._enabled;
+	}
+	set enabled(value) {
+		if (this._enabled === value) return;
+		this._enabled = value;
+		if (!value) {
+			this.endDrag(null);
+			this.clearSelection();
+		}
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.domElement.removeEventListener("pointermove", this.onPointerMove);
+		this.domElement.removeEventListener("pointerdown", this.onPointerDown);
+		this.domElement.removeEventListener("pointerup", this.onPointerUp);
+		this.domElement.removeEventListener("pointercancel", this.onPointerUp);
+		this.endDrag(null);
+		this.clearSelection();
+		for (const [mesh, state] of this.highlighted) {
+			disposeMaterial(state.highlighted);
+			mesh.material = state.original;
+		}
+		this.highlighted.clear();
+	}
+	update() {
+		this.syncModelState(findUSDModels(this.scene));
+	}
+	clearSelection() {
+		if (!this.hovered) return;
+		this.restoreHighlight(this.hovered.object);
+		this.hovered = null;
+		this.onHoverChange?.({
+			joint: null,
+			object: null
+		});
+	}
+	getJointValue(joint, root) {
+		if (root) return this.jointValues.get(`${root.uuid}:${joint.path}`);
+		for (const [key, value] of this.jointValues) if (key.endsWith(`:${joint.path}`)) return value;
+	}
+	setJointValue(joint, value, root) {
+		const models = findUSDModels(this.scene);
+		this.syncModelState(models);
+		for (const model of models) {
+			if (root && model.root !== root) continue;
+			const modelJoint = model.metadata.joints.find((item) => item.path === joint.path);
+			if (!modelJoint || !isManipulableJoint(modelJoint) || !modelJoint.body1) continue;
+			const object = model.objectsByPath.get(modelJoint.body1);
+			if (!object) continue;
+			object.updateMatrix();
+			object.updateMatrixWorld(true);
+			const body0 = modelJoint.body0 ? model.objectsByPath.get(modelJoint.body0) ?? null : null;
+			body0?.updateMatrixWorld(true);
+			const jointKey = jointValueKey(model, modelJoint);
+			const currentValue = this.jointValues.get(jointKey) ?? initialValueForJoint(modelJoint);
+			const { lower, upper } = limitsForJoint(modelJoint);
+			const nextValue = clamp(value, lower, upper);
+			const drag = {
+				model,
+				joint: modelJoint,
+				object,
+				body0,
+				startX: 0,
+				startY: 0,
+				startValue: currentValue,
+				initialLocalMatrix: object.matrix.clone(),
+				jointKey,
+				controlsWasEnabled: null
+			};
+			this.jointValues.set(jointKey, nextValue);
+			updateJointTransform(drag, nextValue);
+			this.onChange?.({
+				joint: modelJoint,
+				object,
+				body0,
+				value: nextValue,
+				previousValue: currentValue
+			});
+			return true;
+		}
+		return false;
+	}
+	onPointerMove = (event) => {
+		if (!this._enabled || this.disposed) return;
+		const activeDrag = this.activeDrag;
+		if (activeDrag) {
+			const pointerDelta = new THREE.Vector2(event.clientX - activeDrag.startX, event.clientY - activeDrag.startY);
+			let mappedValueDelta;
+			if (activeDrag.joint.jointType === "prismatic" && activeDrag.prismaticScreenAxis && activeDrag.prismaticValuePerPixel !== void 0) mappedValueDelta = pointerDelta.dot(activeDrag.prismaticScreenAxis) * activeDrag.prismaticValuePerPixel;
+			else if (activeDrag.joint.jointType === "revolute" && activeDrag.revoluteScreenAxis && activeDrag.revoluteValuePerPixel !== void 0) mappedValueDelta = pointerDelta.dot(activeDrag.revoluteScreenAxis) * activeDrag.revoluteValuePerPixel;
+			else {
+				const { lower, upper } = limitsForJoint(activeDrag.joint);
+				const range = Math.max(upper - lower, activeDrag.joint.jointType === "revolute" ? 90 : .5);
+				mappedValueDelta = (pointerDelta.x - pointerDelta.y) / 280 * range;
+			}
+			const { lower, upper } = limitsForJoint(activeDrag.joint);
+			const previousValue = this.jointValues.get(activeDrag.jointKey) ?? activeDrag.startValue;
+			const nextValue = clamp(activeDrag.startValue + mappedValueDelta, lower, upper);
+			if (nextValue === previousValue) return;
+			this.jointValues.set(activeDrag.jointKey, nextValue);
+			updateJointTransform(activeDrag, nextValue);
+			this.onChange?.({
+				joint: activeDrag.joint,
+				object: activeDrag.object,
+				body0: activeDrag.body0,
+				value: nextValue,
+				previousValue
+			});
+			return;
+		}
+		const hit = this.pickJoint(event);
+		if (this.hovered && this.hovered.object !== hit?.object) this.clearSelection();
+		if (hit && this.hovered?.object !== hit.object) {
+			this.applyHighlight(hit.object);
+			this.hovered = {
+				joint: hit.joint,
+				object: hit.object
+			};
+			this.onHoverChange?.({
+				joint: hit.joint,
+				object: hit.object
+			});
+		}
+	};
+	onPointerDown = (event) => {
+		if (!this._enabled || this.disposed) return;
+		const hit = this.pickJoint(event);
+		if (!hit) return;
+		event.preventDefault();
+		this.domElement.setPointerCapture?.(event.pointerId);
+		const controlsWasEnabled = this.controls?.enabled ?? null;
+		if (this.controls) this.controls.enabled = false;
+		const jointKey = jointValueKey(hit.model, hit.joint);
+		hit.object.updateMatrix();
+		hit.object.updateMatrixWorld(true);
+		hit.body0?.updateMatrixWorld(true);
+		const currentValue = this.jointValues.get(jointKey) ?? initialValueForJoint(hit.joint);
+		const rect = this.domElement.getBoundingClientRect();
+		const prismaticMapping = hit.joint.jointType === "prismatic" ? prismaticDragMapping(hit.joint, hit.object, hit.body0, this.camera, rect) : null;
+		const revoluteMapping = hit.joint.jointType === "revolute" ? revoluteDragMapping(hit.joint, hit.object, hit.body0, this.camera, rect) : null;
+		this.activeDrag = {
+			...hit,
+			startX: event.clientX,
+			startY: event.clientY,
+			startValue: currentValue,
+			initialLocalMatrix: hit.object.matrix.clone(),
+			jointKey,
+			controlsWasEnabled,
+			revoluteScreenAxis: revoluteMapping?.screenAxis,
+			revoluteValuePerPixel: revoluteMapping?.valuePerPixel,
+			prismaticScreenAxis: prismaticMapping?.screenAxis,
+			prismaticValuePerPixel: prismaticMapping?.valuePerPixel
+		};
+	};
+	onPointerUp = (event) => {
+		this.endDrag(event);
+	};
+	pickJoint(event) {
+		this.updatePointer(event);
+		const models = findUSDModels(this.scene);
+		if (models.length === 0) return null;
+		this.syncModelState(models);
+		this.raycaster.setFromCamera(this.pointer, this.camera);
+		const intersections = this.raycaster.intersectObjects(models.map((model) => model.root), true);
+		for (const intersection of intersections) {
+			const hit = jointForObject(models, intersection.object);
+			if (hit) return hit;
+		}
+		return null;
+	}
+	updatePointer(event) {
+		const rect = this.domElement.getBoundingClientRect();
+		this.pointer.x = (event.clientX - rect.left) / rect.width * 2 - 1;
+		this.pointer.y = -((event.clientY - rect.top) / rect.height) * 2 + 1;
+	}
+	syncModelState(models) {
+		const nextSignature = modelStateSignature(models);
+		if (this.modelStateSignature === nextSignature) return;
+		this.endDrag(null);
+		this.clearSelection();
+		this.jointValues.clear();
+		this.modelStateSignature = nextSignature;
+	}
+	endDrag(event) {
+		const activeDrag = this.activeDrag;
+		if (!activeDrag) return;
+		this.activeDrag = null;
+		if (event && this.domElement.hasPointerCapture?.(event.pointerId)) this.domElement.releasePointerCapture(event.pointerId);
+		if (this.controls && activeDrag.controlsWasEnabled !== null) this.controls.enabled = activeDrag.controlsWasEnabled;
+	}
+	applyHighlight(object) {
+		object.traverse((child) => {
+			if (!(child instanceof THREE.Mesh) || this.highlighted.has(child)) return;
+			const highlighted = highlightedMaterials(child.material, this.highlightColor);
+			this.highlighted.set(child, {
+				original: child.material,
+				highlighted
+			});
+			child.material = highlighted;
+		});
+	}
+	restoreHighlight(object) {
+		object.traverse((child) => {
+			if (!(child instanceof THREE.Mesh)) return;
+			const state = this.highlighted.get(child);
+			if (!state) return;
+			child.material = state.original;
+			disposeMaterial(state.highlighted);
+			this.highlighted.delete(child);
+		});
+	}
+};
+//#endregion
+export { USDLoader, USDManipulationControls, buildUSDObject, createUSDLoadedModel, extractUSDModelData };