@openusd-wasm/three-loader 0.0.1 → 0.0.3

package/dist/openusd_three_loader.js

@@ -1,447 +1,7 @@
 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
+import { autoResolveAssetFiles, autoResolveTextureFiles, createPackageTextureResolver, createTextureResolverFromEntries, findPackageRootLayer } from "@openusd-wasm/utils";
 //#region src/metadata.ts
 const MATERIAL_INPUT_SUFFIXES = [
 	"diffuseColor",
@@ -458,6 +18,9 @@ const MATERIAL_INPUT_SUFFIXES = [
 	"file",
 	"wrapS",
 	"wrapT",
+	"st",
+	"in",
+	"varname",
 	"scale",
 	"translation",
 	"rotation"
@@ -476,6 +39,13 @@ function dispose$1(value) {
 function disposeAll(values) {
 	for (let i = values.length - 1; i >= 0; --i) dispose$1(values[i]);
 }
+function pathToString(path) {
+	if (path && typeof path === "object") {
+		const maybePath = path;
+		if (typeof maybePath.GetString === "function") return String(maybePath.GetString());
+	}
+	return String(path);
+}
 function isValid$1(value) {
 	if (!value) return false;
 	if (typeof value.IsValid === "function") return Boolean(value.IsValid());
@@ -533,170 +103,24 @@ function toVector4(value) {
 	}
 	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);
+		return attributeValue(attribute, time, defaultValue);
 	} finally {
 		dispose$1(attribute);
 	}
 }
+function attributeValue(attribute, time, defaultValue = null, authoredOnly = false) {
+	if (!isValid$1(attribute)) return defaultValue;
+	if (authoredOnly && typeof attribute.HasAuthoredValue === "function" && !attribute.HasAuthoredValue()) return defaultValue;
+	const value = attribute.Get(time);
+	return value === null || value === void 0 ? defaultValue : normalizeValue(value);
+}
 function attrMetadata(prim, name, key, defaultValue = null) {
 	const attribute = prim.GetAttribute(name);
 	try {
@@ -707,20 +131,64 @@ function attrMetadata(prim, name, key, defaultValue = null) {
 		dispose$1(attribute);
 	}
 }
-function relationshipTargets(prim, name) {
-	const relationship = prim.GetRelationship(name);
+function relationshipTargetPaths(relationship) {
+	if (!isValid$1(relationship)) return [];
+	const targets = relationship.GetTargets();
+	if (!Array.isArray(targets)) return [];
+	try {
+		return targets.map(pathToString);
+	} finally {
+		disposeAll(targets);
+	}
+}
+function schemaAttributeValue(schema, methodName, time, defaultValue = null, authoredOnly = false) {
+	const attribute = schema[methodName]();
+	try {
+		return attributeValue(attribute, time, defaultValue, authoredOnly);
+	} finally {
+		dispose$1(attribute);
+	}
+}
+function schemaRelationshipTargets(schema, methodName) {
+	const relationship = schema[methodName]();
 	try {
-		if (!isValid$1(relationship)) return [];
-		const targets = relationship.GetTargets();
-		return Array.isArray(targets) ? targets.map(String) : [];
+		return relationshipTargetPaths(relationship);
 	} 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 assetPathValue(assetPath) {
+	const path = typeof assetPath.GetAssetPath === "function" ? String(assetPath.GetAssetPath()) : "";
+	if (!path) return null;
+	const resolvedPath = typeof assetPath.GetResolvedPath === "function" ? String(assetPath.GetResolvedPath()) : "";
+	return resolvedPath ? {
+		path,
+		resolvedPath
+	} : { path };
+}
+function propertyPathPrimPath(path) {
+	if (path && typeof path === "object") {
+		const maybePath = path;
+		if (typeof maybePath.GetPrimPath === "function") {
+			const primPath = maybePath.GetPrimPath();
+			try {
+				return pathToString(primPath) || null;
+			} finally {
+				dispose$1(primPath);
+			}
+		}
+	}
+	return pathToString(path).split(/\.(?:outputs|inputs):/)[0] || null;
+}
+function inputSourcePrimPath(input) {
+	const connections = input.GetRawConnectedSourcePaths();
+	if (!Array.isArray(connections)) return null;
+	try {
+		if (connections.length === 0) return null;
+		return propertyPathPrimPath(connections[0]);
+	} finally {
+		disposeAll(connections);
+	}
 }
 function primChildren(prim) {
 	const children = prim.GetChildren();
@@ -734,24 +202,37 @@ function primAtPath(pxr, stage, path) {
 		dispose$1(sdfPath);
 	}
 }
-function materialBinding(prim) {
-	let current = prim;
-	let ownsCurrent = false;
+function materialBinding(pxr, prim) {
+	const binding = new pxr.UsdShade.MaterialBindingAPI(prim);
 	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;
+		if (!isValid$1(binding)) return null;
+		const computed = binding.ComputeBoundMaterial("", false);
+		if (!Array.isArray(computed)) return null;
+		const [material, bindingRel] = computed;
+		try {
+			if (!isValid$1(bindingRel)) return null;
+			const resolvedPath = pxr.UsdShade.MaterialBindingAPI.GetResolvedTargetPathFromBindingRel(bindingRel);
+			try {
+				const path = pathToString(resolvedPath);
+				if (path) return path;
+			} finally {
+				dispose$1(resolvedPath);
+			}
+			if (!material || !isValid$1(material)) return null;
+			const materialPrim = material.GetPrim();
+			try {
+				return isValid$1(materialPrim) ? String(materialPrim.GetPath()) : null;
+			} finally {
+				dispose$1(materialPrim);
+			}
+		} finally {
+			disposeAll(computed);
 		}
-		return null;
 	} finally {
-		if (ownsCurrent) dispose$1(current);
+		dispose$1(binding);
 	}
 }
-function localTransformForPrim(pxr, prim) {
+function localTransformForPrim(pxr, prim, time) {
 	if (!prim.IsA("Xformable")) return {
 		localMatrix: null,
 		resetsXformStack: false
@@ -762,7 +243,7 @@ function localTransformForPrim(pxr, prim) {
 			localMatrix: null,
 			resetsXformStack: false
 		};
-		const transform = xformable.GetLocalTransformation();
+		const transform = xformable.GetLocalTransformation(time);
 		return {
 			localMatrix: toNumberArray(transform?.matrix),
 			resetsXformStack: Boolean(transform?.resetsXformStack)
@@ -782,7 +263,7 @@ function parentPathForPrim(prim) {
 }
 function getModelView(pxr, prims, time) {
 	return { prims: prims.map((prim) => {
-		const transform = localTransformForPrim(pxr, prim);
+		const transform = localTransformForPrim(pxr, prim, time);
 		return {
 			path: String(prim.GetPath()),
 			parentPath: parentPathForPrim(prim),
@@ -831,13 +312,27 @@ function asFloat(value, fallback = 0) {
 	const number = asFiniteNumber(value);
 	return number === null ? fallback : number;
 }
+function shaderId(shader) {
+	const id = shader.GetShaderId();
+	return typeof id === "string" && id ? id : null;
+}
+function shaderInputValue(shader, inputName, time, defaultValue = null) {
+	const input = shader.GetInput(inputName);
+	try {
+		if (!isValid$1(input)) return defaultValue;
+		const value = input.Get(time);
+		return value === null || value === void 0 ? defaultValue : normalizeValue(value);
+	} finally {
+		dispose$1(input);
+	}
+}
 function shaderInputConnectionPath(shader, inputName) {
-	const attribute = shader.GetAttribute(inputName);
+	const input = shader.GetInput(inputName);
 	try {
-		if (!isValid$1(attribute)) return null;
-		return connectionSourcePath(attribute);
+		if (!isValid$1(input)) return null;
+		return inputSourcePrimPath(input);
 	} finally {
-		dispose$1(attribute);
+		dispose$1(input);
 	}
 }
 function shaderChildByPath(material, path) {
@@ -850,29 +345,41 @@ function shaderChildByPath(material, path) {
 	}
 }
 function primvarNameForTextureShader(pxr, stage, material, textureShader, time) {
-	const stSourcePath = shaderInputConnectionPath(textureShader, "inputs:st");
+	const stSourcePath = shaderInputConnectionPath(textureShader, "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);
+		const stShader = new pxr.UsdShade.Shader(stSource);
+		try {
+			if (!isValid$1(stShader)) return null;
+			const id = shaderId(stShader);
+			if (id === "UsdPrimvarReader_float2") {
+				const varname = shaderInputValue(stShader, "varname", time);
 				return typeof varname === "string" && varname ? varname : null;
-			} finally {
-				dispose$1(nestedSource);
 			}
+			if (id === "UsdTransform2d") {
+				const nestedSourcePath = shaderInputConnectionPath(stShader, "in") ?? shaderInputConnectionPath(stShader, "st");
+				if (!nestedSourcePath) return null;
+				const nestedSource = shaderChildByPath(material, nestedSourcePath) ?? primAtPath(pxr, stage, nestedSourcePath);
+				try {
+					if (!isValid$1(nestedSource)) return null;
+					const nestedShader = new pxr.UsdShade.Shader(nestedSource);
+					try {
+						if (!isValid$1(nestedShader) || shaderId(nestedShader) !== "UsdPrimvarReader_float2") return null;
+						const varname = shaderInputValue(nestedShader, "varname", time);
+						return typeof varname === "string" && varname ? varname : null;
+					} finally {
+						dispose$1(nestedShader);
+					}
+				} finally {
+					dispose$1(nestedSource);
+				}
+			}
+			return null;
+		} finally {
+			dispose$1(stShader);
 		}
-		return null;
 	} finally {
 		dispose$1(stSource);
 	}
@@ -884,10 +391,16 @@ function texturePrimvarForMaterial(pxr, stage, materialPath, time) {
 		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}`;
+			for (const child of children) {
+				if (child.GetTypeName() !== "Shader") continue;
+				const shader = new pxr.UsdShade.Shader(child);
+				try {
+					if (!isValid$1(shader) || shaderId(shader) !== "UsdUVTexture") continue;
+					const varname = primvarNameForTextureShader(pxr, stage, material, shader, time);
+					if (varname) return `primvars:${varname}`;
+				} finally {
+					dispose$1(shader);
+				}
 			}
 		} finally {
 			disposeAll(children);
@@ -904,30 +417,36 @@ function textureTransformForMaterial(pxr, stage, materialPath, time) {
 		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");
+			for (const child of children) {
+				if (child.GetTypeName() !== "Shader") continue;
+				const shader = new pxr.UsdShade.Shader(child);
 				try {
-					if (!isValid$1(stAttribute)) continue;
-					const sourcePath = connectionSourcePath(stAttribute);
+					if (!isValid$1(shader) || shaderId(shader) !== "UsdUVTexture") continue;
+					const sourcePath = shaderInputConnectionPath(shader, "st");
 					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))
-						};
+						if (!isValid$1(transform)) return null;
+						const transformShader = new pxr.UsdShade.Shader(transform);
+						try {
+							if (!isValid$1(transformShader) || shaderId(transformShader) !== "UsdTransform2d") return null;
+							const scale = asVec2(shaderInputValue(transformShader, "scale", time), [1, 1]);
+							const translation = asVec2(shaderInputValue(transformShader, "translation", time), [0, 0]);
+							return {
+								scaleX: scale[0],
+								scaleY: scale[1],
+								translateX: translation[0],
+								translateY: translation[1],
+								rotation: asFloat(shaderInputValue(transformShader, "rotation", time))
+							};
+						} finally {
+							dispose$1(transformShader);
+						}
 					} finally {
 						dispose$1(transform);
 					}
 				} finally {
-					dispose$1(stAttribute);
+					dispose$1(shader);
 				}
 			}
 		} finally {
@@ -963,7 +482,7 @@ function triangulateMesh(pxr, stage, prim, 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 boundMaterial = materialBinding(pxr, 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, []));
@@ -1022,178 +541,244 @@ function getModelElements(pxr, stage, prims, time) {
 		elements.push({
 			path: String(prim.GetPath()),
 			doubleSided: Boolean(attr(prim, "doubleSided", time, false)),
-			material: materialBinding(prim),
+			material: materialBinding(pxr, prim),
 			geometry: triangulateMesh(pxr, stage, prim, time)
 		});
 	}
 	return elements;
 }
-function collectShaderInputs(prim, time) {
+function collectShadeInputs(connectable, time) {
 	const inputs = {};
-	const attributes = prim.GetAttributes();
+	const shadeInputs = connectable.GetInputs();
 	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();
+		for (const input of shadeInputs) {
+			const baseName = String(input.GetBaseName());
+			if (!MATERIAL_INPUT_SUFFIXES.some((suffix) => baseName.endsWith(suffix))) continue;
+			const name = String(input.GetFullName());
+			const value = input.Get(time);
+			const connections = input.GetRawConnectedSourcePaths();
 			if (value !== null && value !== void 0) inputs[name] = normalizeValue(value);
-			if (Array.isArray(connections) && connections.length > 0) inputs[`${name}.connect`] = connections.map(String);
+			if (Array.isArray(connections)) try {
+				if (connections.length > 0) inputs[`${name}.connect`] = connections.map(pathToString);
+			} finally {
+				disposeAll(connections);
+			}
 		}
 	} finally {
-		disposeAll(attributes);
+		disposeAll(shadeInputs);
+	}
+	return inputs;
+}
+function collectShaderSourceAssets(shader) {
+	const inputs = {};
+	const sourceTypes = shader.GetSourceTypes();
+	if (!Array.isArray(sourceTypes)) return inputs;
+	for (const sourceType of sourceTypes) {
+		const sourceTypeName = String(sourceType);
+		const sourceAsset = shader.GetSourceAsset(sourceTypeName);
+		try {
+			const value = assetPathValue(sourceAsset);
+			if (!value) continue;
+			const name = sourceTypeName ? `info:${sourceTypeName}:sourceAsset` : "info:sourceAsset";
+			inputs[name] = value;
+		} finally {
+			dispose$1(sourceAsset);
+		}
 	}
 	return inputs;
 }
-function getModelMaterials(prims, time) {
+function getModelMaterials(pxr, prims, time) {
 	const materials = [];
 	for (const prim of prims) {
 		if (prim.GetTypeName() !== "Material") continue;
+		const material = new pxr.UsdShade.Material(prim);
 		const children = primChildren(prim);
 		const shaders = [];
 		try {
+			if (!isValid$1(material)) continue;
 			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
-				});
+				const shader = new pxr.UsdShade.Shader(child);
+				try {
+					if (!isValid$1(shader)) continue;
+					const idValue = shader.GetShaderId();
+					const id = typeof idValue === "string" && idValue ? idValue : null;
+					const inputs = {
+						...collectShadeInputs(shader, time),
+						...collectShaderSourceAssets(shader)
+					};
+					if (Object.keys(inputs).length === 0 && id !== "UsdPreviewSurface" && id !== "UsdUVTexture") continue;
+					shaders.push({
+						path: String(child.GetPath()),
+						id,
+						inputs
+					});
+				} finally {
+					dispose$1(shader);
+				}
 			}
+			materials.push({
+				path: String(prim.GetPath()),
+				inputs: collectShadeInputs(material, time),
+				shaders
+			});
 		} finally {
 			disposeAll(children);
+			dispose$1(material);
 		}
-		materials.push({
-			path: String(prim.GetPath()),
-			inputs: collectShaderInputs(prim, time),
-			shaders
-		});
 	}
 	return materials;
 }
-function driveForNamespace(prim, namespace, time) {
+function driveForNamespace(pxr, prim, namespace, time) {
+	const driveAPI = new pxr.UsdPhysics.DriveAPI(prim, namespace);
 	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))
+		targetPosition: null,
+		targetVelocity: null,
+		stiffness: null,
+		damping: null,
+		maxForce: null
 	};
-	return Object.values(drive).some((value) => value !== null) ? drive : null;
+	try {
+		if (!isValid$1(driveAPI)) return null;
+		drive.targetPosition = asFiniteNumber(schemaAttributeValue(driveAPI, "GetTargetPositionAttr", time, null, true));
+		drive.targetVelocity = asFiniteNumber(schemaAttributeValue(driveAPI, "GetTargetVelocityAttr", time, null, true));
+		drive.stiffness = asFiniteNumber(schemaAttributeValue(driveAPI, "GetStiffnessAttr", time, null, true));
+		drive.damping = asFiniteNumber(schemaAttributeValue(driveAPI, "GetDampingAttr", time, null, true));
+		drive.maxForce = asFiniteNumber(schemaAttributeValue(driveAPI, "GetMaxForceAttr", time, null, true));
+		return Object.values(drive).some((value) => value !== null) ? drive : null;
+	} finally {
+		dispose$1(driveAPI);
+	}
 }
 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) {
+function jointLimitSchema(pxr, prim, typeName) {
+	switch (typeName) {
+		case "PhysicsRevoluteJoint": return new pxr.UsdPhysics.RevoluteJoint(prim);
+		case "PhysicsPrismaticJoint": return new pxr.UsdPhysics.PrismaticJoint(prim);
+		case "PhysicsSphericalJoint": return new pxr.UsdPhysics.SphericalJoint(prim);
+		case "PhysicsDistanceJoint": return new pxr.UsdPhysics.DistanceJoint(prim);
+		default: return null;
+	}
+}
+function jointAxisAndLimits(pxr, prim, typeName, time) {
+	const schema = jointLimitSchema(pxr, prim, typeName);
+	if (!schema) return {
+		axis: null,
+		lowerLimit: null,
+		upperLimit: null
+	};
+	try {
+		if (!isValid$1(schema)) return {
+			axis: null,
+			lowerLimit: null,
+			upperLimit: null
+		};
+		if (typeName === "PhysicsSphericalJoint") {
+			const axis = schemaAttributeValue(schema, "GetAxisAttr", time);
+			return {
+				axis: typeof axis === "string" ? axis : null,
+				lowerLimit: asFiniteNumber(schemaAttributeValue(schema, "GetConeAngle0LimitAttr", time, null, true)),
+				upperLimit: asFiniteNumber(schemaAttributeValue(schema, "GetConeAngle1LimitAttr", time, null, true))
+			};
+		}
+		if (typeName === "PhysicsDistanceJoint") return {
+			axis: null,
+			lowerLimit: asFiniteNumber(schemaAttributeValue(schema, "GetMinDistanceAttr", time, null, true)),
+			upperLimit: asFiniteNumber(schemaAttributeValue(schema, "GetMaxDistanceAttr", time, null, true))
+		};
+		const axis = schemaAttributeValue(schema, "GetAxisAttr", time);
+		return {
+			axis: typeof axis === "string" ? axis : null,
+			lowerLimit: asFiniteNumber(schemaAttributeValue(schema, "GetLowerLimitAttr", time)),
+			upperLimit: asFiniteNumber(schemaAttributeValue(schema, "GetUpperLimitAttr", time))
+		};
+	} finally {
+		dispose$1(schema);
+	}
+}
+function getModelJoints(pxr, 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 joint = new pxr.UsdPhysics.Joint(prim);
+		if (!isValid$1(joint)) {
+			dispose$1(joint);
+			continue;
+		}
+		const angularDrive = driveForNamespace(pxr, prim, "angular", time);
+		const linearDrive = driveForNamespace(pxr, 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 body0 = schemaRelationshipTargets(joint, "GetBody0Rel");
+		const body1 = schemaRelationshipTargets(joint, "GetBody1Rel");
 		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
-		});
+		const axisAndLimits = jointAxisAndLimits(pxr, prim, typeName, time);
+		try {
+			joints.push({
+				path: String(prim.GetPath()),
+				name: String(prim.GetName()),
+				typeName,
+				jointType,
+				body0: body0[0] ?? null,
+				body1: body1[0] ?? null,
+				...axisAndLimits,
+				localPos0: toVector3(schemaAttributeValue(joint, "GetLocalPos0Attr", time, [
+					0,
+					0,
+					0
+				]), [
+					0,
+					0,
+					0
+				]),
+				localPos1: toVector3(schemaAttributeValue(joint, "GetLocalPos1Attr", time, [
+					0,
+					0,
+					0
+				]), [
+					0,
+					0,
+					0
+				]),
+				localRot0: toVector4(schemaAttributeValue(joint, "GetLocalRot0Attr", time)),
+				localRot1: toVector4(schemaAttributeValue(joint, "GetLocalRot1Attr", time)),
+				enabled: Boolean(schemaAttributeValue(joint, "GetJointEnabledAttr", time, true)),
+				drive,
+				drives
+			});
+		} finally {
+			dispose$1(joint);
+		}
 	}
 	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
+			startTimeCode: stage.GetStartTimeCode(),
+			endTimeCode: stage.GetEndTimeCode(),
+			timeCodesPerSecond: stage.GetTimeCodesPerSecond()
 		};
 	} 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);
+		return localTransformForPrim(pxr, prim, time).localMatrix;
 	} finally {
 		dispose$1(time);
 	}
@@ -1210,10 +795,10 @@ function animationSampleFrames(start, end) {
 	});
 }
 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 start = stageInfo.startTimeCode;
+	const end = stageInfo.endTimeCode;
+	const timeCodesPerSecond = stageInfo.timeCodesPerSecond;
+	if (end <= start) return [];
 	const frames = animationSampleFrames(start, end);
 	if (frames.length < 2) return [];
 	const transforms = [];
@@ -1260,8 +845,8 @@ function extractUSDModelData(pxr, stage, options = {}) {
 			stage: stageInfo,
 			view: getModelView(pxr, prims, time),
 			elements: getModelElements(pxr, stage, prims, time),
-			materials: getModelMaterials(prims, time),
-			joints: getModelJoints(prims, time),
+			materials: getModelMaterials(pxr, prims, time),
+			joints: getModelJoints(pxr, prims, time),
 			animations: getModelAnimations(pxr, prims, stageInfo)
 		};
 	} finally {
@@ -1566,13 +1151,19 @@ function deleteFileIfExists(pxr, path) {
 		if (pxr.FS.exists(path)) pxr.FS.deleteFile(path);
 	} catch {}
 }
-async function writeUSDInput(pxr, input, options) {
-	const directory = joinFsPath(options.workingDirectory, String(++nextLoadId));
+function createUSDInputDirectory(pxr, workingDirectory) {
+	const directory = joinFsPath(workingDirectory, String(++nextLoadId));
 	pxr.FS.createDir(directory);
-	for (const [relativePath, file] of Object.entries(options.files ?? {})) {
+	return directory;
+}
+async function writeUSDFiles(pxr, directory, files) {
+	for (const [relativePath, file] of Object.entries(files ?? {})) {
 		const filePath = joinFsPath(directory, relativePath);
 		pxr.FS.writeFile(filePath, await sourceToWritableData(file));
 	}
+}
+async function writeUSDInput(pxr, directory, input, options) {
+	await writeUSDFiles(pxr, directory, options.files);
 	const path = joinFsPath(directory, sanitizeFileName(options.fileName));
 	pxr.FS.writeFile(path, input);
 	return path;
@@ -1655,15 +1246,19 @@ var USDLoader = class extends Loader {
 		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 packageRootLayer = extension === "usdz" && writableData instanceof Uint8Array ? mergedOptions.usdzLayer ?? findPackageRootLayer(writableData) ?? void 0 : mergedOptions.usdzLayer;
+		const rootFileName = sanitizeFileName(mergedOptions.fileName);
+		const directory = createUSDInputDirectory(pxr, mergedOptions.workingDirectory);
+		const filePath = await writeUSDInput(pxr, directory, writableData, {
+			fileName: rootFileName,
+			files: mergedOptions.files
 		});
-		const { stage, identifier } = openStage(pxr, filePath, extension, mergedOptions.usdzLayer);
+		let autoFiles = extension !== "usdz" ? await autoResolveAssetFiles(pxr, filePath, {
+			...mergedOptions,
+			fileName: rootFileName
+		}) : {};
+		await writeUSDFiles(pxr, directory, autoFiles);
+		const { stage, identifier } = openStage(pxr, filePath, extension, packageRootLayer);
 		try {
 			const metadata = extractUSDModelData(pxr, stage, {
 				sourcePath: mergedOptions.sourcePath,
@@ -1719,7 +1314,7 @@ function limitsForJoint(joint) {
 }
 function initialValueForJoint(joint) {
 	const { lower, upper } = limitsForJoint(joint);
-	return clamp(joint.drive?.targetPosition ?? lower, lower, upper);
+	return clamp(joint.drive?.targetPosition ?? 0, lower, upper);
 }
 function isManipulableJoint(joint) {
 	return joint.enabled && (joint.jointType === "revolute" || joint.jointType === "prismatic");
@@ -1785,7 +1380,12 @@ function jointValueKey(model, joint) {
 	return `${model.root.uuid}:${joint.path}`;
 }
 function localAxisForJoint(joint) {
-	return axisVectors[joint.axis ?? ""]?.clone() ?? axisVectors.X.clone();
+	const axis = axisVectors[joint.axis ?? ""]?.clone() ?? axisVectors.X.clone();
+	const rotation = joint.localRot0;
+	if (!rotation) return axis;
+	const quaternion = new THREE.Quaternion(rotation[1] ?? 0, rotation[2] ?? 0, rotation[3] ?? 0, rotation[0] ?? 1);
+	if (quaternion.lengthSq() < 1e-10) return axis;
+	return axis.applyQuaternion(quaternion.normalize());
 }
 function localPivotForJoint(joint) {
 	return new THREE.Vector3(joint.localPos0[0] ?? 0, joint.localPos0[1] ?? 0, joint.localPos0[2] ?? 0);