@openusd-wasm/pxr 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 KeJun <https://github.com/kejunmao>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,74 @@
+# @openusd-wasm/pxr
+
+Community ESM facade for OpenUSD `pxr` WebAssembly bindings.
+
+This package is the high-level facade. The generated Emscripten module and Wasm
+binary live in `@openusd-wasm/core`, matching the split used by projects such
+as `ffmpeg.wasm`.
+
+```text
+@openusd-wasm/pxr   facade and TypeScript declarations
+@openusd-wasm/core  Emscripten core JavaScript and Wasm binary
+```
+
+Use a statically imported core factory with explicit asset URLs:
+
+```ts
+import createOpenUsdPxrWasm from '@openusd-wasm/core'
+import { wasmURL, workerURL } from '@openusd-wasm/core/urls'
+import { createPxr } from '@openusd-wasm/pxr'
+
+const pxr = await createPxr({
+  core: createOpenUsdPxrWasm,
+  wasmURL,
+  workerURL,
+})
+```
+
+This form is recommended for bundlers such as Next.js/Turbopack because the
+Emscripten core module is visible as a normal static import. For custom hosting
+or CDN usage, you can still pass URLs manually:
+
+```ts
+const pxr = await createPxr({
+  coreURL: 'https://cdn.example.com/openusd_pxr_wasm.js',
+  wasmURL: 'https://cdn.example.com/openusd_pxr_wasm.wasm',
+})
+```
+
+The returned namespace exposes `Gf`, `Sdf`, `Usd`, `UsdGeom`, `UsdPhysics`,
+`UsdUtils`, and `FS` helpers for the virtual filesystem.
+
+## Unsupported APIs
+
+The facade intentionally exposes a small JavaScript-friendly subset of `pxr`.
+The following areas are not wrapped yet.
+
+### Gf
+
+- Camera, Rotation, and non-4d matrix variants need value conversion coverage before exposing.
+- Line, plane, frustum, interval, and dual quaternion helpers are deferred until their dependent value types are bound.
+
+### Sdf
+
+- PrimSpec, AttributeSpec, and RelationshipSpec mutation proxies are deferred because list/proxy lifetimes need JS-safe wrappers.
+- ChangeBlock, LayerOffset, Reference/Payload value classes, VariantSpec, and VariantSetSpec APIs are deferred to the next Sdf expansion.
+
+### Usd
+
+- EditTarget/EditContext, StageCache, StagePopulationMask, StageLoadRules, VariantSets, Payloads, and PrimRange iterator objects are not wrapped yet.
+- Generated Usd schema class coverage beyond concrete schema registration is deferred to schema-driven generation.
+
+### UsdGeom
+
+- Generated schema classes beyond Xform, Sphere, Cube, and Mesh are deferred to schema-driven generation.
+- PointInstancer, Camera, Imageable, BBoxCache overrides, and typed-array zero-copy bridges are deferred.
+
+### UsdPhysics
+
+- Generated schema classes beyond CollisionAPI and RigidBodyAPI are deferred to schema-driven generation.
+- Joints, limits, drives, parsing utilities, and metrics helpers are deferred to the next physics expansion.
+
+### UsdUtils
+
+- StageCache, SparseValueWriter, Stitch, StitchClips, dependency extraction, FlattenLayerStack, TimeCodeRange, localization, and compliance helpers are deferred.

package/dist/openusd_pxr.d.ts

@@ -0,0 +1,190 @@
+//#region src/bindings.d.ts
+interface EmscriptenFs {
+  filesystems?: Record<string, unknown>;
+  mkdir(path: string): void;
+  mount(fsType: unknown, opts: Record<string, unknown>, mountPoint: string): void;
+  unmount(mountPoint: string): void;
+  writeFile(path: string, data: string | ArrayBuffer | ArrayBufferView): void;
+  readFile(path: string, opts?: unknown): unknown;
+  readdir(path: string): string[];
+  stat(path: string): {
+    mode: number;
+    size: number;
+  };
+  isDir(mode: number): boolean;
+  isFile(mode: number): boolean;
+  unlink(path: string): void;
+  rmdir(path: string): void;
+  rename(oldPath: string, newPath: string): void;
+  syncfs(populate: boolean, callback: (err?: unknown) => void): void;
+}
+interface WasmModule extends Record<string, unknown> {
+  FS?: EmscriptenFs;
+  mainScriptUrlOrBlob?: unknown;
+  PxrJsInitializeOpenUsdRuntime?: () => void;
+}
+interface PxrDisposable {
+  delete(): void;
+  using<T>(fn: (value: this) => T): T;
+}
+type PxrInstance = PxrDisposable & Record<string, any>;
+type PxrClass = {
+  new (...args: any[]): PxrInstance;
+  [key: string]: any;
+};
+type PxrFunction = (...args: any[]) => any;
+type PxrBindingObject = Record<string, any>;
+type PxrNamespaceValue = PxrClass | PxrFunction | PxrBindingObject;
+type PxrNamespace = Record<string, PxrNamespaceValue>;
+type PxrModuleName = 'Gf' | 'Sdf' | 'Usd' | 'UsdGeom' | 'UsdPhysics' | 'UsdUtils';
+//#endregion
+//#region src/modules/gf.d.ts
+interface PxrGfNamespace {
+  Vec2f: PxrClass;
+  Vec2d: PxrClass;
+  Vec2h: PxrClass;
+  Vec2i: PxrClass;
+  Vec3f: PxrClass;
+  Vec3d: PxrClass;
+  Vec3h: PxrClass;
+  Vec3i: PxrClass;
+  Vec4f: PxrClass;
+  Vec4d: PxrClass;
+  Vec4h: PxrClass;
+  Vec4i: PxrClass;
+  Matrix3d: PxrClass;
+  Matrix4d: PxrClass;
+  Quatf: PxrClass;
+  Quatd: PxrClass;
+  Quath: PxrClass;
+  Range1d: PxrClass;
+  Range2d: PxrClass;
+  Range3d: PxrClass;
+  Range3f: PxrClass;
+  BBox3d: PxrClass;
+}
+//#endregion
+//#region src/modules/sdf.d.ts
+interface PxrSdfNamespace {
+  Path: PxrClass;
+  AssetPath: PxrClass;
+  Layer: PxrClass;
+  PrimSpec: PxrClass;
+  ValueTypeName: PxrClass;
+  ValueTypeNames: PxrBindingObject;
+}
+//#endregion
+//#region src/modules/usd.d.ts
+interface PxrUsdNamespace {
+  Stage: PxrClass;
+  Prim: PxrClass;
+  Attribute: PxrClass;
+  Relationship: PxrClass;
+  References: PxrClass;
+  TimeCode: PxrClass;
+}
+//#endregion
+//#region src/modules/usdGeom.d.ts
+interface PxrUsdGeomNamespace {
+  Xform: PxrClass;
+  Sphere: PxrClass;
+  Cube: PxrClass;
+  Mesh: PxrClass;
+  Xformable: PxrClass;
+  XformOp: PxrClass;
+  Primvar: PxrClass;
+  PrimvarsAPI: PxrClass;
+  BBoxCache: PxrClass;
+  SetStageMetersPerUnit: PxrFunction;
+  SetStageUpAxis: PxrFunction;
+  GetStageUpAxis: PxrFunction;
+  Tokens: PxrBindingObject;
+}
+//#endregion
+//#region src/modules/usdPhysics.d.ts
+interface PxrUsdPhysicsNamespace {
+  CollisionAPI: PxrClass;
+  RigidBodyAPI: PxrClass;
+}
+//#endregion
+//#region src/modules/usdUtils.d.ts
+interface PxrUsdUtilsNamespace {
+  CreateNewUsdzPackage: PxrFunction;
+}
+//#endregion
+//#region src/modules/index.d.ts
+interface PxrModuleMap {
+  Gf: PxrGfNamespace;
+  Sdf: PxrSdfNamespace;
+  Usd: PxrUsdNamespace;
+  UsdGeom: PxrUsdGeomNamespace;
+  UsdPhysics: PxrUsdPhysicsNamespace;
+  UsdUtils: PxrUsdUtilsNamespace;
+}
+//#endregion
+//#region src/index.d.ts
+type WasmFactory = (options?: Record<string, unknown>) => Promise<WasmModule> | WasmModule;
+type WasmFactoryModule = {
+  default?: WasmFactory;
+  createOpenUsdPxrWasm?: WasmFactory;
+};
+type PxrResourceURL = string | URL | Blob;
+type PxrWasmFactory = WasmFactory;
+type PxrWasmFactoryModule = WasmFactoryModule;
+type PxrCoreFactory = WasmFactory | WasmFactoryModule;
+interface PxrFsListEntry {
+  name: string;
+  path: string;
+  mode: number;
+  size: number;
+  isDir: boolean;
+  isFile: boolean;
+}
+interface PxrFsHelpers {
+  raw: EmscriptenFs;
+  mkdirp(path: string): void;
+  createDir(path: string): void;
+  deleteDir(path: string): void;
+  listDir(path: string): PxrFsListEntry[];
+  mount(mount: Record<string, unknown>): void;
+  mount(fsType: string, options: Record<string, unknown>, mountPoint: string): void;
+  unmount(mountPoint: string): void;
+  mountNodeFS(mountPoint: string, root?: string): void;
+  mountWorkerFS(mountPoint: string, options?: Record<string, unknown>): void;
+  mountIDBFS(mountPoint: string, options?: Record<string, unknown>): void;
+  writeFile(path: string, data: string | ArrayBuffer | ArrayBufferView): void;
+  readFile(path: string, encodingOrOpts?: 'binary' | 'utf8' | 'utf-8' | Record<string, unknown>): unknown;
+  exists(path: string): boolean;
+  deleteFile(path: string): void;
+  unlink(path: string): void;
+  rename(oldPath: string, newPath: string): void;
+  renameFile(oldPath: string, newPath: string): void;
+  syncfs(populate?: boolean): Promise<void>;
+}
+interface Pxr extends PxrModuleMap {
+  _module: WasmModule;
+  FS: PxrFsHelpers;
+  using<T extends PxrDisposable>(value: T): T;
+}
+interface CreatePxrOptions extends Record<string, unknown> {
+  core?: PxrCoreFactory;
+  coreURL?: PxrResourceURL;
+  wasmURL: PxrResourceURL;
+  workerURL?: PxrResourceURL;
+  mainScriptUrlOrBlob?: string | URL | Blob;
+  locateFile?: (path: string, prefix: string) => string;
+  mounts?: Array<Record<string, unknown>>;
+  files?: Record<string, string | ArrayBuffer | ArrayBufferView>;
+  preRun?: Function | Function[];
+}
+interface PxrCoreAssets {
+  core?: PxrCoreFactory;
+  coreURL?: PxrResourceURL;
+  wasmURL: PxrResourceURL;
+  workerURL?: PxrResourceURL;
+}
+type CreatePxrFromCoreOptions = Omit<CreatePxrOptions, 'core' | 'coreURL' | 'wasmURL' | 'workerURL'>;
+declare function createPxr(options: CreatePxrOptions): Promise<Pxr>;
+declare function createPxrFromCore(core: PxrCoreAssets, options?: CreatePxrFromCoreOptions): Promise<Pxr>;
+//#endregion
+export { CreatePxrFromCoreOptions, CreatePxrOptions, type EmscriptenFs, Pxr, type PxrBindingObject, type PxrClass, PxrCoreAssets, PxrCoreFactory, type PxrDisposable, PxrFsHelpers, PxrFsListEntry, type PxrFunction, type PxrGfNamespace, type PxrInstance, type PxrModuleMap, type PxrModuleName, type PxrNamespace, type PxrNamespaceValue, PxrResourceURL, type PxrSdfNamespace, type PxrUsdGeomNamespace, type PxrUsdNamespace, type PxrUsdPhysicsNamespace, type PxrUsdUtilsNamespace, PxrWasmFactory, PxrWasmFactoryModule, type WasmModule, createPxr, createPxr as default, createPxrFromCore };

package/dist/openusd_pxr.js

@@ -0,0 +1,441 @@
+//#region src/bindings.ts
+function flatName(moduleName, name) {
+	return `PxrJs${moduleName}${name}`;
+}
+function attachUsing(value) {
+	if (!value) return value;
+	Object.defineProperty(value, "using", {
+		enumerable: false,
+		value(callback) {
+			try {
+				return callback(value);
+			} finally {
+				if (value && value.delete) value.delete();
+			}
+		}
+	});
+	return value;
+}
+function installUsing(cls) {
+	if (!cls || !cls.prototype || cls.prototype.using) return cls;
+	try {
+		Object.defineProperty(cls.prototype, "using", {
+			enumerable: false,
+			value(callback) {
+				try {
+					return callback(this);
+				} finally {
+					if (this && this.delete) this.delete();
+				}
+			}
+		});
+	} catch {}
+	return cls;
+}
+function mapClass(module, embindName) {
+	const cls = module[embindName];
+	if (typeof cls !== "function") throw new Error(`Missing Embind export ${embindName}`);
+	return installUsing(cls);
+}
+function mapFunction(module, embindName) {
+	const fn = module[embindName];
+	if (typeof fn !== "function") throw new Error(`Missing Embind export ${embindName}`);
+	return (...args) => fn(...args);
+}
+function mapObject(module, embindName) {
+	const fn = module[embindName];
+	if (typeof fn !== "function") throw new Error(`Missing Embind export ${embindName}`);
+	return fn();
+}
+function bindClass(module, moduleName, name) {
+	return mapClass(module, flatName(moduleName, name));
+}
+function bindFunction(module, moduleName, name) {
+	return mapFunction(module, flatName(moduleName, name));
+}
+function bindObject(module, moduleName, name) {
+	return mapObject(module, flatName(moduleName, name));
+}
+//#endregion
+//#region src/modules/gf.ts
+function buildGfNamespace(module) {
+	return {
+		Vec2f: bindClass(module, "Gf", "Vec2f"),
+		Vec2d: bindClass(module, "Gf", "Vec2d"),
+		Vec2h: bindClass(module, "Gf", "Vec2h"),
+		Vec2i: bindClass(module, "Gf", "Vec2i"),
+		Vec3f: bindClass(module, "Gf", "Vec3f"),
+		Vec3d: bindClass(module, "Gf", "Vec3d"),
+		Vec3h: bindClass(module, "Gf", "Vec3h"),
+		Vec3i: bindClass(module, "Gf", "Vec3i"),
+		Vec4f: bindClass(module, "Gf", "Vec4f"),
+		Vec4d: bindClass(module, "Gf", "Vec4d"),
+		Vec4h: bindClass(module, "Gf", "Vec4h"),
+		Vec4i: bindClass(module, "Gf", "Vec4i"),
+		Matrix3d: bindClass(module, "Gf", "Matrix3d"),
+		Matrix4d: bindClass(module, "Gf", "Matrix4d"),
+		Quatf: bindClass(module, "Gf", "Quatf"),
+		Quatd: bindClass(module, "Gf", "Quatd"),
+		Quath: bindClass(module, "Gf", "Quath"),
+		Range1d: bindClass(module, "Gf", "Range1d"),
+		Range2d: bindClass(module, "Gf", "Range2d"),
+		Range3d: bindClass(module, "Gf", "Range3d"),
+		Range3f: bindClass(module, "Gf", "Range3f"),
+		BBox3d: bindClass(module, "Gf", "BBox3d")
+	};
+}
+//#endregion
+//#region src/modules/sdf.ts
+function buildSdfNamespace(module) {
+	return {
+		Path: bindClass(module, "Sdf", "Path"),
+		AssetPath: bindClass(module, "Sdf", "AssetPath"),
+		Layer: bindClass(module, "Sdf", "Layer"),
+		PrimSpec: bindClass(module, "Sdf", "PrimSpec"),
+		ValueTypeName: bindClass(module, "Sdf", "ValueTypeName"),
+		ValueTypeNames: bindObject(module, "Sdf", "ValueTypeNames")
+	};
+}
+//#endregion
+//#region src/modules/usd.ts
+function buildUsdNamespace(module) {
+	return {
+		Stage: bindClass(module, "Usd", "Stage"),
+		Prim: bindClass(module, "Usd", "Prim"),
+		Attribute: bindClass(module, "Usd", "Attribute"),
+		Relationship: bindClass(module, "Usd", "Relationship"),
+		References: bindClass(module, "Usd", "References"),
+		TimeCode: bindClass(module, "Usd", "TimeCode")
+	};
+}
+//#endregion
+//#region src/modules/usdGeom.ts
+function buildUsdGeomNamespace(module) {
+	return {
+		Xform: bindClass(module, "UsdGeom", "Xform"),
+		Sphere: bindClass(module, "UsdGeom", "Sphere"),
+		Cube: bindClass(module, "UsdGeom", "Cube"),
+		Mesh: bindClass(module, "UsdGeom", "Mesh"),
+		Xformable: bindClass(module, "UsdGeom", "Xformable"),
+		XformOp: bindClass(module, "UsdGeom", "XformOp"),
+		Primvar: bindClass(module, "UsdGeom", "Primvar"),
+		PrimvarsAPI: bindClass(module, "UsdGeom", "PrimvarsAPI"),
+		BBoxCache: bindClass(module, "UsdGeom", "BBoxCache"),
+		SetStageMetersPerUnit: bindFunction(module, "UsdGeom", "SetStageMetersPerUnit"),
+		SetStageUpAxis: bindFunction(module, "UsdGeom", "SetStageUpAxis"),
+		GetStageUpAxis: bindFunction(module, "UsdGeom", "GetStageUpAxis"),
+		Tokens: bindObject(module, "UsdGeom", "Tokens")
+	};
+}
+//#endregion
+//#region src/modules/usdPhysics.ts
+function buildUsdPhysicsNamespace(module) {
+	return {
+		CollisionAPI: bindClass(module, "UsdPhysics", "CollisionAPI"),
+		RigidBodyAPI: bindClass(module, "UsdPhysics", "RigidBodyAPI")
+	};
+}
+//#endregion
+//#region src/modules/usdUtils.ts
+function buildUsdUtilsNamespace(module) {
+	return { CreateNewUsdzPackage: bindFunction(module, "UsdUtils", "CreateNewUsdzPackage") };
+}
+//#endregion
+//#region src/modules/index.ts
+function buildPxrModules(module) {
+	return {
+		Gf: buildGfNamespace(module),
+		Sdf: buildSdfNamespace(module),
+		Usd: buildUsdNamespace(module),
+		UsdGeom: buildUsdGeomNamespace(module),
+		UsdPhysics: buildUsdPhysicsNamespace(module),
+		UsdUtils: buildUsdUtilsNamespace(module)
+	};
+}
+//#endregion
+//#region src/modules/sdfConvenience.ts
+function installGetter(cls, name, getter) {
+	if (!cls?.prototype) return;
+	if (Object.getOwnPropertyDescriptor(cls.prototype, name)) return;
+	try {
+		Object.defineProperty(cls.prototype, name, {
+			enumerable: false,
+			get() {
+				return getter(this);
+			}
+		});
+	} catch {}
+}
+function installAccessor(cls, name, getter, setter) {
+	if (!cls?.prototype) return;
+	if (Object.getOwnPropertyDescriptor(cls.prototype, name)) return;
+	try {
+		Object.defineProperty(cls.prototype, name, {
+			enumerable: false,
+			get() {
+				return getter(this);
+			},
+			set(next) {
+				setter(this, next);
+			}
+		});
+	} catch {}
+}
+function installSdfConvenienceAccessors(pxr) {
+	installGetter(pxr.Sdf.AssetPath, "path", (value) => value.GetAssetPath());
+	installGetter(pxr.Sdf.AssetPath, "resolvedPath", (value) => value.GetResolvedPath());
+	installAccessor(pxr.Sdf.Layer, "subLayerPaths", (value) => value.GetSubLayerPaths(), (value, next) => value.SetSubLayerPaths(next));
+}
+//#endregion
+//#region src/index.ts
+function mkdirp(FS, path) {
+	const parts = path.split("/").filter(Boolean);
+	let current = path.startsWith("/") ? "/" : "";
+	for (const part of parts) {
+		current = current === "/" ? `/${part}` : `${current}/${part}`;
+		try {
+			FS.mkdir(current);
+		} catch (err) {
+			try {
+				if (FS.isDir(FS.stat(current).mode)) continue;
+			} catch {}
+			throw err;
+		}
+	}
+}
+function parentPath(path) {
+	const parts = path.split("/");
+	parts.pop();
+	const parent = parts.join("/");
+	if (parent) return parent;
+	return path.startsWith("/") ? "/" : ".";
+}
+function joinFsPath(base, name) {
+	if (base === "/") return `/${name}`;
+	return `${base.replace(/\/+$/, "")}/${name}`;
+}
+function ensureParent(FS, path) {
+	const parent = parentPath(path);
+	if (parent !== ".") mkdirp(FS, parent);
+}
+function isNodeLike() {
+	const processLike = globalThis.process;
+	return !!processLike?.versions?.node && processLike.type !== "renderer";
+}
+function isBlobLike(value) {
+	return typeof Blob !== "undefined" && value instanceof Blob;
+}
+function toUrlString(value, baseUrl = import.meta.url) {
+	if (value === void 0 || value === null) return void 0;
+	if (isBlobLike(value)) return URL.createObjectURL(value);
+	if (value instanceof URL) return value.href;
+	if (typeof value !== "string") return value;
+	try {
+		return new URL(value, baseUrl).href;
+	} catch {
+		return value;
+	}
+}
+function requireUrlString(value, name) {
+	if (value === void 0 || value === null) throw new TypeError(`${name} is required`);
+	const url = toUrlString(value);
+	if (typeof url !== "string") throw new TypeError(`${name} must resolve to a string URL`);
+	return url;
+}
+function fileUrlToPathString(value) {
+	const url = value instanceof URL ? value : new URL(value);
+	if (url.protocol !== "file:") return value instanceof URL ? url.href : value;
+	return decodeURIComponent(url.pathname);
+}
+function toWorkerScript(value) {
+	if (value === void 0 || value === null || isBlobLike(value)) return value;
+	if (isNodeLike()) {
+		if (value instanceof URL) return fileUrlToPathString(value);
+		if (typeof value === "string" && value.startsWith("file:")) return fileUrlToPathString(value);
+		return value;
+	}
+	return toUrlString(value);
+}
+function resolveWasmFactory(core, source = "core") {
+	const factory = typeof core === "function" ? core : core.default ?? core.createOpenUsdPxrWasm;
+	if (typeof factory !== "function") throw new Error(`Unable to load OpenUSD Wasm factory from ${source}`);
+	return factory;
+}
+function runtimeImport(url) {
+	return Function("url", "return import(url)")(url);
+}
+async function loadWasmFactory(core, coreURL) {
+	if (core !== void 0) return resolveWasmFactory(core);
+	const url = requireUrlString(coreURL, "coreURL");
+	return resolveWasmFactory(await runtimeImport(url), url);
+}
+function buildLocateFile({ wasmURL, workerURL, locateFile }) {
+	const resolvedWasmURL = requireUrlString(wasmURL, "wasmURL");
+	const resolvedWorkerURL = workerURL === void 0 ? void 0 : requireUrlString(workerURL, "workerURL");
+	return (path, prefix) => {
+		if (path.endsWith(".wasm")) return resolvedWasmURL;
+		if (resolvedWorkerURL && (path.endsWith(".worker.js") || path.endsWith(".worker.mjs"))) return String(resolvedWorkerURL);
+		if (locateFile) return locateFile(path, prefix);
+		return `${prefix || ""}${path}`;
+	};
+}
+function requireFs(module) {
+	if (!module.FS) throw new Error("openusd_pxr_wasm was built without FS export");
+	return module.FS;
+}
+function normalizeMountArgs(mountOrType, options = {}, mountPoint) {
+	if (typeof mountOrType === "string") return {
+		type: mountOrType,
+		...options || {},
+		mountPoint
+	};
+	return mountOrType || {};
+}
+function mountFilesystem(module, mountOrType, options, mountPointArg) {
+	const FS = requireFs(module);
+	const mount = normalizeMountArgs(mountOrType, options, mountPointArg);
+	const type = typeof mount.type === "string" ? mount.type : "MEMFS";
+	const mountPoint = typeof mount.mountPoint === "string" ? mount.mountPoint : typeof mount.path === "string" ? mount.path : void 0;
+	if (!mountPoint) throw new Error("mountPoint is required");
+	mkdirp(FS, mountPoint);
+	if (type === "MEMFS") return;
+	const fsType = FS.filesystems?.[type];
+	if (!fsType) throw new Error(`${type} is not available in this Wasm build`);
+	const opts = { ...mount };
+	delete opts.type;
+	delete opts.mountPoint;
+	delete opts.path;
+	FS.mount(fsType, opts, mountPoint);
+}
+function installFiles(module, files) {
+	if (!files) return;
+	const FS = requireFs(module);
+	for (const [path, data] of Object.entries(files)) {
+		ensureParent(FS, path);
+		FS.writeFile(path, data);
+	}
+}
+function normalizeCallbacks(callbacks) {
+	if (!callbacks) return [];
+	return Array.isArray(callbacks) ? callbacks : [callbacks];
+}
+function readFile(FS, path, encodingOrOpts) {
+	if (typeof encodingOrOpts === "string") {
+		if (encodingOrOpts === "utf8" || encodingOrOpts === "utf-8") return FS.readFile(path, { encoding: "utf8" });
+		return FS.readFile(path);
+	}
+	return FS.readFile(path, encodingOrOpts);
+}
+function listDir(FS, path) {
+	return FS.readdir(path).filter((name) => name !== "." && name !== "..").map((name) => {
+		const childPath = joinFsPath(path, name);
+		const stat = FS.stat(childPath);
+		return {
+			name,
+			path: childPath,
+			mode: stat.mode,
+			size: stat.size,
+			isDir: FS.isDir(stat.mode),
+			isFile: FS.isFile(stat.mode)
+		};
+	});
+}
+function defaultNodeRoot() {
+	if (!globalThis.process?.cwd) throw new Error("A NODEFS root is required outside Node.js");
+	return globalThis.process.cwd();
+}
+function buildFsHelpers(module) {
+	const FS = requireFs(module);
+	const rename = (oldPath, newPath) => {
+		ensureParent(FS, newPath);
+		FS.rename(oldPath, newPath);
+	};
+	return {
+		raw: FS,
+		mkdirp: (path) => mkdirp(FS, path),
+		createDir: (path) => mkdirp(FS, path),
+		deleteDir: (path) => FS.rmdir(path),
+		listDir: (path) => listDir(FS, path),
+		mount: (mountOrType, options, mountPoint) => mountFilesystem(module, mountOrType, options, mountPoint),
+		unmount: (mountPoint) => FS.unmount(mountPoint),
+		mountNodeFS: (mountPoint, root = defaultNodeRoot()) => mountFilesystem(module, {
+			type: "NODEFS",
+			mountPoint,
+			root
+		}),
+		mountWorkerFS: (mountPoint, options = {}) => mountFilesystem(module, {
+			type: "WORKERFS",
+			mountPoint,
+			...options
+		}),
+		mountIDBFS: (mountPoint, options = {}) => mountFilesystem(module, {
+			type: "IDBFS",
+			mountPoint,
+			...options
+		}),
+		writeFile: (path, data) => {
+			ensureParent(FS, path);
+			FS.writeFile(path, data);
+		},
+		readFile: (path, encodingOrOpts) => readFile(FS, path, encodingOrOpts),
+		exists: (path) => {
+			try {
+				FS.stat(path);
+				return true;
+			} catch {
+				return false;
+			}
+		},
+		deleteFile: (path) => FS.unlink(path),
+		unlink: (path) => FS.unlink(path),
+		rename,
+		renameFile: rename,
+		syncfs: (populate = false) => new Promise((resolve, reject) => {
+			FS.syncfs(populate, (err) => err ? reject(err) : resolve());
+		})
+	};
+}
+function buildPxr(module) {
+	const pxr = {
+		_module: module,
+		FS: buildFsHelpers(module),
+		using: attachUsing,
+		...buildPxrModules(module)
+	};
+	installSdfConvenienceAccessors(pxr);
+	return pxr;
+}
+function initializeOpenUsdRuntime(module) {
+	if (typeof module.PxrJsInitializeOpenUsdRuntime !== "function") throw new Error("openusd_pxr_wasm was built without OpenUSD runtime initialization support");
+	module.PxrJsInitializeOpenUsdRuntime();
+}
+async function createPxr(options) {
+	if (!options) throw new TypeError("createPxr requires options with core or coreURL and wasmURL");
+	const { core, coreURL, wasmURL, workerURL, mainScriptUrlOrBlob, mounts = [], files, preRun, locateFile, ...wasmOptions } = options;
+	wasmOptions.locateFile = buildLocateFile({
+		wasmURL,
+		workerURL,
+		locateFile
+	});
+	wasmOptions.preRun = [...normalizeCallbacks(preRun), (module) => {
+		for (const mount of mounts) mountFilesystem(module, mount);
+		installFiles(module, files);
+	}];
+	if (mainScriptUrlOrBlob !== void 0) wasmOptions.mainScriptUrlOrBlob = toWorkerScript(mainScriptUrlOrBlob);
+	else if (workerURL !== void 0) wasmOptions.mainScriptUrlOrBlob = toWorkerScript(workerURL);
+	const module = await (await loadWasmFactory(core, coreURL))(wasmOptions);
+	initializeOpenUsdRuntime(module);
+	return buildPxr(module);
+}
+async function createPxrFromCore(core, options = {}) {
+	if (!core) throw new TypeError("createPxrFromCore requires @openusd-wasm/core assets");
+	return createPxr({
+		...options,
+		core: core.core,
+		coreURL: core.coreURL,
+		wasmURL: core.wasmURL,
+		workerURL: core.workerURL ?? core.coreURL
+	});
+}
+//#endregion
+export { createPxr, createPxr as default, createPxrFromCore };

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@openusd-wasm/pxr",
+  "type": "module",
+  "version": "0.0.1",
+  "description": "Community TypeScript facade for OpenUSD pxr WebAssembly bindings.",
+  "license": "MIT",
+  "homepage": "https://github.com/openusd-wasm/openusd-pxr-wasm",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/openusd-wasm/openusd-pxr-wasm.git",
+    "directory": "packages/pxr"
+  },
+  "main": "./dist/openusd_pxr.js",
+  "module": "./dist/openusd_pxr.js",
+  "types": "./dist/openusd_pxr.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/openusd_pxr.d.ts",
+      "import": "./dist/openusd_pxr.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@types/node": "^25.6.2",
+    "@typescript/native-preview": "7.0.0-dev.20260509.2",
+    "tsdown": "^0.22.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.5"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "debug": "tsdown --sourcemap",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
+}