Emit the ``ExportTo`` body — every write-back-to-mjs line. Order: canon exports, xml_enum exports, per-attr exports, data-packed exports, targ

Emit the ``ImportFromXml`` body — every read-from-XML line. Order: common imports prefix (name/class), xml_enum imports, per-attr imports, can

Emit the per-type XML-attr formatter line(s) for a single attr. Returns a list of indented C++ lines (one for scalars, multiple for TArray loo

Emit ``pos="x y z"`` / ``quat="w x y z"`` formatters for the canonicalisation-owned UPROPERTYs. Round-trips through the same UEToMjPosition /

Emit the per-attr if/else-if chain that picks the XML string for the chosen enum value.

Emit per-attr UPROPERTY blocks (the bulk of the component's Details panel). Attrs handled by xml_enum_attrs are skipped — those use a hand-dec

Emit the out-of-line ``ApplyToSpec`` and ``ApplyOverridesToModel`` bodies for a synthetic struct whose mirror writes go through mjSpec + mjMod

Emit UPROPERTY blocks for the URLab-extra fields (non-mjxmacro additions like ``MemoryMB`` on MjOption). Returns prop_lines + extras_meta. Eac

Emit the templated inline ``ApplyTo`` body for pure-mirror synthetic structs (mjStatistic etc.). The shape mirrors the out-of-line ApplyToSpec

Emit the UPROPERTY block for the mjxmacro mirror fields and return the parallel ``fields_meta`` list. ``fields_meta`` carries the per-field sh

Emit import for an mjs name-string field that the schema spells out across several xor attrs (e.g. mjsEquality.name1 is one of body1/joint1/ t

Emit a guarded loop / scalar block that applies per-element conversions to a UPROPERTY at import time. ``side`` is "import" or "export"; only

Emit the EXPORT side of a unit_conversion rule: build a temp value per-element, apply the conversion, then write to ``Element->mjs_field[i]``

Emit the URLab-enum -> mjt* / mjsField mapping inside CODEGEN_EXPORT. Gated on ``bOverride_X`` when ``has_override_toggle`` is true (default).

Emit UPROPERTY decls for xml_enum_attrs entries that opt in via ``emit_property_decl: true``. URLab usually hand-declares the UE-side enum pro

Pull out the body of ``std::vector<const char*> MJCF[nMJCF] = { ... };``.

Return the index of the ``}`` matching the ``{`` at ``open_idx``. Tracks brace depth across string/char literals and line/block comments so a

Pull URLab's hand-rolled ``EMj*`` enums out of the merged introspect snapshot when present. Snapshot path produces real ENUM_CONSTANT_DECL mem

SHA-256 of the concatenated header content. Lets callers skip re-running the snapshot when nothing upstream changed.

Link bOverride_X toggles to their guarded properties.

Load introspect + project into the legacy mjspec shape via the same helper the runtime uses. Mirrors the conftest fixture.

Return the location's file as a forward-slash path relative to the plugin root, so the snapshot is byte-identical across developers (n

Main parse loop. Walks source sequentially, building up ParsedClass/ParsedEnum objects. Strategy: find UCLASS/USTRUCT/UENUM blocks, then scan

Whitespace-tolerant float list parser for inline mesh attributes.

Parse `X(type, name, count)` or `X(name, count)` or `X(name)` or `XVEC(...)`. mjxmacro flat-struct blocks have a few shapes: - `X(type, name,

Build a tree from the flat block list using ``"<"`` / ``">"`` markers.

Locate clang-format: $CLANG_FORMAT, then PATH, then VS2022's LLVM.

Convert ``Public/MuJoCo/Components/Actuators/MjMotorActuator.h`` to the include path ``MuJoCo/Components/Actuators/MjMotorActuator.h``.

Rewrite an asset element's ``file=`` so it resolves from ``root_dir`` (the output _ue.xml location) after the declaring file has been spliced in.

Walk ``public_root`` for every ``.h`` file declaring ``enum class EMj* : uint8 { ... }`` and return ``{enum_name: [members]}``. Members are st

Walk every .h under ``urlab_source_root`` looking for ``enum class EMj* : uint8`` blocks; hand each cleaned block to libclang for member + val

Return the set of schema attr names that an ``mjs_setTo*`` call consumes for the given subtype. These attrs are packed into the mjs spec via t

True when ``ue_shape`` can legitimately back ``c_shape``. A ``TArray<X>`` (array) is shape-compatible with a fixed-size C array (vec) because

Return the index just past the matching ``)`` for a function-call opener at ``start``. Handles nested parens — naive ``[^)]*`` would bail on `

Remove characters that look like braces but live inside a string/char literal or comment. Used by ``_check_brace_balance`` so a diagnostic mes

Replaces all content inside { ... } with just {} to prevent capturing local vars.

Erase ``UMETA(...)`` and ``UENUM(...)`` function-like macros so a plain libclang pass can compile the enum block. Each macro turns into the em

Return a flat list of ``[strings...]`` for each ``{...}`` block in the MJCF body, in source order. Comments are stripped (``//`` line comments

Visit every cursor in the translation unit. ``mujoco_include`` is the include root; we only capture decls whose file lives under it (so libc /

Write docs/api/index.md — master class list, ordered by source folder structure.

Either apply, print diff, or check. Returns process exit code. Writes use ``newline="\\n"`` and a binary compare so a codegen run on Windows

Clean up a mesh using trimesh.

Diff two schema snapshots. Returns structured diff.

Read MjBind.h, fill each view struct's ``// --- CODEGEN_VIEW_<View>_FIELDS_START/END ---`` and ``// --- CODEGEN_VIEW_<View>_BIND_START/END ---

For categories whose layout is multi_uclass, emit: - the base class block (between PROPERTIES / IMPORT / EXPORT tags) - per-subtype UCLA

Generate a C++ header that exposes schema attribute lists per category to URLab automation tests. Every category emits a ``CatProps()`` access

Emit the body of a `BuildSchemaAttrsXml() const -> FString` method. For categories with ``xml_passthrough_emission: true`` in their codegen r

Walk ``MuJoCo/Generated/`` under public + private roots and return any file the codegen no longer plans to emit. A category removed from rules

Resolve every <include> into a single self-contained <mujoco> tree. gym-aloha (and many MJCF models) split a robot across <include> fragments

Print collected diagnostics to stderr, advance ``fired_count`` by the number flushed, and clear the pending list.

Yield every attr absorbed by any canonicalisation in ``elem_canons``. Skips unknown canon keys silently — diagnostics for those live in the ru

Return the ordered prop names the codegen will emit for one category. Order matches the canonical emission order: canon- owned properties firs

Rewrite ``<mesh vertex="..." face="...">`` (MuJoCo's inline-data form) to ``<mesh file="...">`` by emitting an OBJ next to the rest of the mes

Parse a single .h file and return a ParsedFile dict.

Pretty-print the diff results.

Parse MJCF XML, convert meshes, resolve conflicts, write updated XML.

Post-process parsed data to push inherited properties and functions down into subclasses. This ensures API pages for classes like UMjJointVel